/**
 * Pure intent-mapping gate for `edit_elements`.
 *
 * Takes model-proposed element updates + the trusted slide inventory and either
 * returns validated `EditIntent`s (`element.update` / `element.updateMany`) or a
 * refusal. Malformed / out-of-contract proposals never partially apply.
 *
 * No I/O, no React, no store — fixture-testable in isolation.
 */

import type { PPTElement } from '@openmaic/dsl';
import sceneSchemaJson from '@openmaic/dsl/schema/scene.schema.json';
import type { EditIntent } from '@openmaic/editor/core';
import tinycolor from 'tinycolor2';
import { MIN_SIZE } from '@/configs/element';

const DEFAULT_MIN_SIZE = 20;
const LINE_STROKE_MIN = 1;
const LINE_STROKE_MAX = 100;
const GROUP_TRANSLATION_TOLERANCE = 1e-6;
const MERGED_STYLE_PROPS = new Set(['outline', 'shadow', 'filters']);
/** Sanity bounds so model JSON cannot park elements at 1e15. */
const COORD_MIN = -5000;
const COORD_MAX = 20000;
const FILTER_UNITS: Record<string, string> = {
  blur: 'px',
  brightness: '%',
  contrast: '%',
  grayscale: '%',
  saturate: '%',
  'hue-rotate': 'deg',
  sepia: '%',
  invert: '%',
  opacity: '%',
};
const FILTER_RANGES: Record<string, readonly [number, number]> = {
  blur: [0, 100],
  brightness: [0, 1000],
  contrast: [0, 1000],
  grayscale: [0, 100],
  saturate: [0, 1000],
  'hue-rotate': [-36000, 36000],
  sepia: [0, 100],
  invert: [0, 100],
  opacity: [0, 100],
};
const FILTER_IDENTITY: Record<string, number> = {
  blur: 0,
  brightness: 100,
  contrast: 100,
  grayscale: 0,
  saturate: 100,
  'hue-rotate': 0,
  sepia: 0,
  invert: 0,
  opacity: 100,
};

/** Geometry + style props the AI may mutate. Content / identity are rejected. */
export const ALLOWED_EDIT_PROPS = new Set([
  // geometry
  'left',
  'top',
  'width',
  'height',
  'rotate',
  // shared chrome
  'fill',
  'opacity',
  'outline',
  'shadow',
  // text / shape text chrome (not HTML body)
  'defaultColor',
  'defaultFontName',
  'lineHeight',
  'wordSpace',
  'paragraphSpace',
  'vertical',
  'vAlign',
  // line / latex / audio color
  'color',
  // shape
  'gradient',
  // image chrome
  'filters',
  'radius',
  'flipH',
  'flipV',
  'colorMask',
  'fixedRatio',
  // chart chrome
  'themeColors',
  'textColor',
  'lineColor',
  // code chrome (not `lines` / not user-visible fileName)
  'fontSize',
  'showLineNumbers',
]);

/** Props that must never be written by this vertical. */
export const FORBIDDEN_EDIT_PROPS = new Set([
  'id',
  'type',
  'lock',
  'groupId',
  'link',
  'content',
  'text',
  'src',
  'mediaRef',
  'lines',
  'latex',
  'html',
  'data',
  'path',
  'viewBox',
  'pathFormula',
  'keypoints',
  'start',
  'end',
  'broken',
  'broken2',
  'curve',
  'cubic',
  'colWidths',
  'rowHeights',
  'cellMinHeight',
  'animations',
  'fileName',
]);

/** Text-chrome keys that live under `shape.text` for shape elements. */
export const SHAPE_TEXT_CHROME_PROPS = new Set([
  'defaultColor',
  'defaultFontName',
  'lineHeight',
  'wordSpace',
  'paragraphSpace',
]);
const TEXT_GLYPH_PROPS = new Set([...SHAPE_TEXT_CHROME_PROPS, 'vertical', 'shadow']);

export type JsonSchema = {
  $ref?: string;
  anyOf?: JsonSchema[];
  type?: string | string[];
  const?: unknown;
  enum?: unknown[];
  properties?: Record<string, JsonSchema>;
  required?: string[];
  additionalProperties?: boolean | JsonSchema;
  items?: JsonSchema | JsonSchema[];
  minimum?: number;
  maximum?: number;
};

type SchemaDocument = {
  definitions?: Record<string, JsonSchema>;
};

const sceneSchema = sceneSchemaJson as SchemaDocument;
const schemaDefinitions = sceneSchema.definitions ?? {};

const ELEMENT_SCHEMA_DEFINITION_BY_TYPE = new Map<string, string>([
  ['text', 'PPTTextElement'],
  ['image', 'PPTImageElement'],
  ['shape', 'PPTShapeElement'],
  ['line', 'PPTLineElement'],
  ['chart', 'PPTChartElement'],
  ['table', 'PPTTableElement'],
  ['latex', 'PPTLatexElement'],
  ['video', 'PPTVideoElement'],
  ['audio', 'PPTAudioElement'],
  ['code', 'PPTCodeElement'],
]);

const REQUIRED_SCHEMA_DEFINITIONS = [
  'Gradient',
  'GradientColor',
  'PPTElement',
  'PPTElementOutline',
  'PPTElementShadow',
  'ShapeText',
  ...ELEMENT_SCHEMA_DEFINITION_BY_TYPE.values(),
];

const SHAPE_TEXT_SCHEMA_ALIASES = new Map<string, string>([
  ['defaultColor', 'defaultColor'],
  ['defaultFontName', 'defaultFontName'],
  ['lineHeight', 'lineHeight'],
  ['wordSpace', 'wordSpace'],
  ['paragraphSpace', 'paragraphSpace'],
  ['vAlign', 'align'],
]);

function schemaSourceError(detail: string): Error {
  return new Error(
    `edit_elements gate schema sanity check failed: ${detail}. Rebuild @openmaic/dsl to regenerate dist/schema/scene.schema.json.`,
  );
}

function assertGateSchemaSource(definitions: Record<string, JsonSchema>): void {
  for (const name of REQUIRED_SCHEMA_DEFINITIONS) {
    if (!definitions[name]) {
      throw schemaSourceError(`missing schema definition ${JSON.stringify(name)}`);
    }
  }

  const pptElementOptions = definitions.PPTElement?.anyOf ?? [];
  const pptElementRefs = new Set(
    pptElementOptions.map((option) => (option.$ref ? decodeRefName(option.$ref) : null)),
  );
  for (const definitionName of ELEMENT_SCHEMA_DEFINITION_BY_TYPE.values()) {
    if (!pptElementRefs.has(definitionName)) {
      throw schemaSourceError(`PPTElement union missing ${JSON.stringify(definitionName)}`);
    }
  }
}

function decodeRefName(ref: string): string | null {
  const m = ref.match(/^#\/definitions\/(.+)$/);
  return m ? m[1].replace(/~1/g, '/').replace(/~0/g, '~') : null;
}

assertGateSchemaSource(schemaDefinitions);

function resolveSchema(schema: JsonSchema, seen = new Set<string>()): JsonSchema {
  if (!schema.$ref) return schema;
  const name = decodeRefName(schema.$ref);
  if (!name || seen.has(name)) return schema;
  const target = schemaDefinitions[name];
  if (!target) return schema;
  seen.add(name);
  return resolveSchema(target, seen);
}

function elementTypeFromSchema(schema: JsonSchema): string | null {
  const typeSchema = resolveSchema(schema.properties?.type ?? {});
  return typeof typeSchema.const === 'string' ? typeSchema.const : null;
}

/**
 * Lockstep with packages/@openmaic/dsl/scripts/gen-schema.mjs: the package
 * export @openmaic/dsl/schema/scene.schema.json is generated from slides.ts.
 */
function buildEditablePropSchemas(): Map<string, Map<string, JsonSchema>> {
  const out = new Map<string, Map<string, JsonSchema>>();
  const elementUnion = resolveSchema(schemaDefinitions.PPTElement ?? {});
  for (const option of elementUnion.anyOf ?? []) {
    const elementSchema = resolveSchema(option);
    const elementType = elementTypeFromSchema(elementSchema);
    if (!elementType || !elementSchema.properties) continue;
    out.set(elementType, new Map(Object.entries(elementSchema.properties)));
  }

  const shapeProps = out.get('shape');
  const shapeTextSchema = shapeProps?.get('text');
  const shapeTextProps = shapeTextSchema ? resolveSchema(shapeTextSchema).properties : undefined;
  if (shapeProps && shapeTextProps) {
    for (const [flatProp, schemaProp] of SHAPE_TEXT_SCHEMA_ALIASES) {
      const subschema = shapeTextProps[schemaProp];
      if (subschema) shapeProps.set(flatProp, subschema);
    }
  }

  return out;
}

const EDITABLE_PROP_SCHEMAS_BY_TYPE = buildEditablePropSchemas();

for (const type of ELEMENT_SCHEMA_DEFINITION_BY_TYPE.keys()) {
  if (!EDITABLE_PROP_SCHEMAS_BY_TYPE.has(type)) {
    throw schemaSourceError(`unable to map editable schemas for ${JSON.stringify(type)} elements`);
  }
}

export function getEditablePropSchema(type: string, key: string): JsonSchema | null {
  if (!ALLOWED_EDIT_PROPS.has(key) || FORBIDDEN_EDIT_PROPS.has(key)) return null;
  return EDITABLE_PROP_SCHEMAS_BY_TYPE.get(type)?.get(key) ?? null;
}

/** Validate one complete element against the generated DSL schema. */
export function validateElementAgainstDslSchema(element: PPTElement): string | null {
  const definitionName = ELEMENT_SCHEMA_DEFINITION_BY_TYPE.get(element.type);
  const schema = definitionName ? schemaDefinitions[definitionName] : undefined;
  if (!schema) return `element type ${JSON.stringify(element.type)} is out of contract`;
  return validateJsonSchemaSubset(element, schema, 'element');
}

export interface ElementInventoryItem {
  id: string;
  type: string;
  left: number;
  top: number;
  width: number;
  height?: number;
  rotate?: number;
  lock?: boolean;
  groupId?: string;
  /** Short human-readable label for the model (stripped text / name / type). */
  label: string;
  /** Style props currently on the element that the DSL owns and AI may edit. */
  style: Record<string, unknown>;
  /** True when element-level defaultColor would be hidden by inline HTML color. */
  hasInlineTextColor?: boolean;
  /** True when element-level defaultFontName would be hidden by inline HTML font-family. */
  hasInlineFontFamily?: boolean;
  /** True when element-level lineHeight would be hidden by inline HTML line-height. */
  hasInlineLineHeight?: boolean;
  /** True when element-level wordSpace would be hidden by inline HTML letter-spacing. */
  hasInlineLetterSpacing?: boolean;
  /** True when element-level paragraphSpace would be hidden by inline HTML margin-bottom. */
  hasInlineParagraphSpacing?: boolean;
  /** True when element-level vertical writing mode would be hidden by descendant CSS. */
  hasInlineWritingMode?: boolean;
  /** True when text-element shadow would be hidden by descendant text-shadow CSS. */
  hasInlineTextShadow?: boolean;
  /** Image clip shape used to decide whether radius is visually supported. */
  imageClipShape?: string;
  /** True when a line has a non-zero start/end segment. */
  lineHasVisiblePath?: boolean;
  /** True when a zero-length line can still paint an endpoint marker. */
  lineHasEndpointMarker?: boolean;
  /** True when shape pattern paint is present and fill/gradient application would remove it. */
  hasPattern?: boolean;
  /** True when a shape currently has visible label text. */
  hasShapeText?: boolean;
  /** True when inline KaTeX HTML color would override the latex container color. */
  hasInlineLatexColor?: boolean;
  /** True when imported cell-level borders make table outline cross-renderer inconsistent. */
  hasCellBorders?: boolean;
  /** Chart subtype used for renderer capability checks. */
  chartType?: string;
  /** True when chart data produces a renderer option instead of null. */
  hasRenderableChartData?: boolean;
  /** Number of leading palette colors consumed by the current chart data. */
  chartColorCount?: number;
  /** True when a text element currently has visible glyph content. */
  hasTextGlyphs?: boolean;
  /** True when text has layout-visible characters, even if their paint is transparent. */
  hasTextContent?: boolean;
  /** True when a latex element has a visible HTML or SVG rendering branch. */
  hasRenderableLatex?: boolean;
  /** Active latex renderer branch. */
  latexRenderMode?: 'html' | 'svg' | 'none';
}

const TEXT_VISIBILITY_SOURCE = Symbol('textVisibilitySource');
type TextVisibilitySource = {
  content: string;
  colorProp: 'defaultColor' | 'color';
  color?: unknown;
  opacity?: unknown;
  shadow?: { h?: unknown; v?: unknown; blur?: unknown; color?: unknown };
};
type InternalElementInventoryItem = ElementInventoryItem & {
  [TEXT_VISIBILITY_SOURCE]?: TextVisibilitySource;
};

export interface ProposedElementUpdate {
  id: string;
  props: Record<string, unknown>;
}

export type EditElementsGateResult =
  | { ok: true; intents: EditIntent[] }
  | { ok: false; reason: string };

function isFiniteNumber(v: unknown): v is number {
  return typeof v === 'number' && Number.isFinite(v);
}

function isColorString(v: unknown): boolean {
  if (typeof v !== 'string' || v.length > 64) return false;
  const value = v.trim();
  const lower = value.toLowerCase();
  const number = String.raw`[+-]?(?:\d+(?:\.\d*)?|\.\d+)`;
  const percentage = `${number}%`;
  const rgbNumbers = `${number}\\s*,\\s*${number}\\s*,\\s*${number}`;
  const rgbPercentages = `${percentage}\\s*,\\s*${percentage}\\s*,\\s*${percentage}`;
  const alpha = number;
  const hue = `${number}(?:deg)?`;
  const functional =
    new RegExp(`^rgb\\(\\s*(?:${rgbNumbers}|${rgbPercentages})\\s*\\)$`, 'i').test(value) ||
    new RegExp(
      `^rgba\\(\\s*(?:${rgbNumbers}|${rgbPercentages})\\s*,\\s*${alpha}\\s*\\)$`,
      'i',
    ).test(value) ||
    new RegExp(`^hsl\\(\\s*${hue}\\s*,\\s*${percentage}\\s*,\\s*${percentage}\\s*\\)$`, 'i').test(
      value,
    ) ||
    new RegExp(
      `^hsla\\(\\s*${hue}\\s*,\\s*${percentage}\\s*,\\s*${percentage}\\s*,\\s*${alpha}\\s*\\)$`,
      'i',
    ).test(value);
  const syntaxIsCssColor =
    /^#[0-9a-f]{3,4}(?:[0-9a-f]{3,4})?$/i.test(value) ||
    functional ||
    lower === 'transparent' ||
    Object.hasOwn(tinycolor.names, lower);
  return syntaxIsCssColor && tinycolor(value).isValid();
}

function isNonEmptyString(v: unknown, max = 200): v is string {
  return typeof v === 'string' && v.length > 0 && v.length <= max;
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return !!value && typeof value === 'object' && !Array.isArray(value);
}

function deepEqual(a: unknown, b: unknown): boolean {
  if (Object.is(a, b)) return true;
  if (Array.isArray(a) && Array.isArray(b)) {
    return a.length === b.length && a.every((value, index) => deepEqual(value, b[index]));
  }
  if (isRecord(a) && isRecord(b)) {
    const aKeys = Object.keys(a);
    const bKeys = Object.keys(b);
    return (
      aKeys.length === bKeys.length &&
      aKeys.every((key) => Object.hasOwn(b, key) && deepEqual(a[key], b[key]))
    );
  }
  return false;
}

const PRO_EDITOR_SUPPORTED_TYPES = new Set([
  'text',
  'image',
  'shape',
  'line',
  'chart',
  'table',
  'latex',
  'video',
]);

function schemaTypeMatches(value: unknown, type: string): boolean {
  switch (type) {
    case 'string':
      return typeof value === 'string';
    case 'number':
      return isFiniteNumber(value);
    case 'boolean':
      return typeof value === 'boolean';
    case 'object':
      return value !== null && typeof value === 'object' && !Array.isArray(value);
    case 'array':
      return Array.isArray(value);
    default:
      return true;
  }
}

function describeSchemaTypes(type: string | string[]): string {
  return Array.isArray(type) ? type.join('|') : type;
}

const SUPPORTED_SCHEMA_KEYWORDS = new Set([
  '$ref',
  'anyOf',
  'type',
  'const',
  'enum',
  'properties',
  'required',
  'additionalProperties',
  'items',
  'minimum',
  'maximum',
]);

function propPath(path: string): string {
  return path.startsWith('prop ') ? path : `prop ${path}`;
}

function unsupportedSchemaConstruct(path: string): string {
  return `${propPath(path)} uses a schema construct the gate cannot validate`;
}

function isUnsupportedSchemaConstruct(err: string | null): boolean {
  return err?.includes('uses a schema construct the gate cannot validate') ?? false;
}

function lacksSupportedSchemaKeywords(schema: JsonSchema): boolean {
  const keys = Object.keys(schema);
  return keys.length > 0 && !keys.some((key) => SUPPORTED_SCHEMA_KEYWORDS.has(key));
}

export function validateJsonSchemaSubset(
  value: unknown,
  schema: JsonSchema,
  path: string,
): string | null {
  const s = resolveSchema(schema);
  if (s.$ref || lacksSupportedSchemaKeywords(s)) return unsupportedSchemaConstruct(path);

  if ('anyOf' in s) {
    if (!Array.isArray(s.anyOf) || s.anyOf.length === 0) {
      return unsupportedSchemaConstruct(path);
    }
    const errors = s.anyOf
      .map((option) => validateJsonSchemaSubset(value, option, path))
      .filter(Boolean);
    if (errors.length !== s.anyOf.length) return null;
    return errors.find(isUnsupportedSchemaConstruct) ?? `${path} does not match any allowed schema`;
  }

  if ('const' in s && !Object.is(value, s.const)) {
    return `${path} must be ${JSON.stringify(s.const)}`;
  }
  if (s.enum && !s.enum.some((item) => Object.is(item, value))) {
    return `${path} must be one of ${s.enum.map((item) => JSON.stringify(item)).join('|')}`;
  }

  if (s.type) {
    const types = Array.isArray(s.type) ? s.type : [s.type];
    if (!types.some((type) => schemaTypeMatches(value, type))) {
      return types.includes('number')
        ? `${path} must be a finite number`
        : `${path} must be ${describeSchemaTypes(s.type)}`;
    }
  }

  if (typeof value === 'number') {
    if (!Number.isFinite(value)) return `${path} must be a finite number`;
    if (typeof s.minimum === 'number' && value < s.minimum) {
      return `${path} out of bounds (${s.minimum}..${s.maximum ?? '∞'})`;
    }
    if (typeof s.maximum === 'number' && value > s.maximum) {
      return `${path} out of bounds (${s.minimum ?? '-∞'}..${s.maximum})`;
    }
  }

  if (s.properties) {
    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
      return `${path} must be object`;
    }
    const obj = value as Record<string, unknown>;
    for (const required of s.required ?? []) {
      if (!(required in obj)) return `${path}.${required} is required`;
    }
    if (s.additionalProperties === false) {
      for (const key of Object.keys(obj)) {
        if (!s.properties[key]) return `${path}.${key} is out of contract`;
      }
    }
    for (const [key, nested] of Object.entries(s.properties)) {
      if (key in obj) {
        const err = validateJsonSchemaSubset(obj[key], nested, `${path}.${key}`);
        if (err) return err;
      }
    }
  }

  if (s.items) {
    if (!Array.isArray(value)) return `${path} must be array`;
    if (Array.isArray(s.items)) {
      for (let i = 0; i < value.length; i++) {
        const itemSchema = s.items[Math.min(i, s.items.length - 1)];
        if (!itemSchema) continue;
        const err = validateJsonSchemaSubset(value[i], itemSchema, `${path}[${i}]`);
        if (err) return err;
      }
    } else {
      for (let i = 0; i < value.length; i++) {
        const err = validateJsonSchemaSubset(value[i], s.items, `${path}[${i}]`);
        if (err) return err;
      }
    }
  }

  return null;
}

/** Signed angle in (-180, 180], matching the rotate gesture core. */
export function normalizeRotate(degrees: number): number {
  let r = degrees % 360;
  if (r > 180) r -= 360;
  if (r <= -180) r += 360;
  return r;
}

function minSizeFor(type: string): number {
  return MIN_SIZE[type] ?? DEFAULT_MIN_SIZE;
}

function clampCoord(n: number, label: string): number {
  if (n < COORD_MIN || n > COORD_MAX) {
    throw new Error(`${label} out of bounds (${COORD_MIN}..${COORD_MAX})`);
  }
  return n;
}

const COLOR_STRING_PROPS = new Set([
  'fill',
  'defaultColor',
  'color',
  'textColor',
  'lineColor',
  'colorMask',
]);

/**
 * Structural, enum, and ownership mismatches refuse so the model learns the
 * contract; numeric overshoot on a valid prop clamps later, matching gestures.
 */
function validatePolicyOverlay(key: string, value: unknown): string | null {
  if (COLOR_STRING_PROPS.has(key)) {
    return isColorString(value) ? null : `${key} must be a color string`;
  }

  switch (key) {
    case 'defaultFontName':
      return isNonEmptyString(value, 80) ? null : `${key} must be a non-empty string`;
    case 'opacity':
      return isFiniteNumber(value) ? null : 'opacity must be a finite number';
    case 'lineHeight':
      if (!isFiniteNumber(value)) return `${key} must be a finite number`;
      if (value < 1 || value > 3) return `${key} out of bounds (1..3)`;
      return null;
    case 'wordSpace':
    case 'paragraphSpace':
      if (!isFiniteNumber(value)) return `${key} must be a finite number`;
      if (value < 0 || value > 100) return `${key} out of bounds (0..100)`;
      return null;
    case 'radius':
      if (!isFiniteNumber(value)) return `${key} must be a finite number`;
      if (value < 0 || value > 500) return `${key} out of bounds (0..500)`;
      return null;
    case 'fontSize':
      if (!isFiniteNumber(value)) return `${key} must be a finite number`;
      if (value < 8 || value > 200) return `${key} out of bounds (8..200)`;
      return null;
    case 'outline': {
      const o = value as Record<string, unknown>;
      if (Object.keys(o).length === 0) return 'outline must contain at least one property';
      if ('width' in o && (!isFiniteNumber(o.width) || o.width < 0 || o.width > LINE_STROKE_MAX)) {
        return 'outline.width must be a finite number in range';
      }
      if ('color' in o && !isColorString(o.color)) return 'outline.color must be a color string';
      return null;
    }
    case 'shadow': {
      const o = value as Record<string, unknown>;
      if (!isColorString(o.color)) return 'shadow.color must be a color string';
      if (!isFiniteNumber(o.blur) || o.blur < 0) {
        return 'shadow.blur must be a non-negative finite number';
      }
      return null;
    }
    case 'gradient': {
      const o = value as { colors?: unknown[] };
      if (!Array.isArray(o.colors) || o.colors.length === 0 || o.colors.length > 10) {
        return 'gradient.colors must contain 1..10 stops';
      }
      for (let i = 0; i < o.colors.length; i++) {
        const stop = o.colors[i] as Record<string, unknown>;
        if (!isFiniteNumber(stop.pos) || stop.pos < 0 || stop.pos > 100) {
          return `gradient.colors[${i}].pos must be a number in [0,100]`;
        }
        if (!isColorString(stop.color)) {
          return `gradient.colors[${i}].color must be a color string`;
        }
      }
      return null;
    }
    case 'filters': {
      if (Object.keys(value as Record<string, unknown>).length === 0) {
        return 'filters must contain at least one property';
      }
      for (const [filterKey, filterValue] of Object.entries(value as Record<string, unknown>)) {
        if (typeof filterValue !== 'string') return `filters.${filterKey} must be a string`;
        if (filterValue.length > 40) return `filters.${filterKey} must be at most 40 chars`;
        const unit = FILTER_UNITS[filterKey];
        const match = filterValue.trim().match(/^([+-]?(?:\d+(?:\.\d*)?|\.\d+))(px|%|deg)?$/);
        if (!match || (match[2] && match[2] !== unit)) {
          return `filters.${filterKey} must be a numeric string${unit ? ` with optional ${unit}` : ''}`;
        }
        const numeric = Number(match[1]);
        const [min, max] = FILTER_RANGES[filterKey] ?? [
          Number.NEGATIVE_INFINITY,
          Number.POSITIVE_INFINITY,
        ];
        if (numeric < min || numeric > max) {
          return `filters.${filterKey} out of bounds (${min}..${max})`;
        }
      }
      return null;
    }
    case 'themeColors':
      if (!Array.isArray(value) || value.length === 0 || !value.every(isColorString)) {
        return 'themeColors must be a non-empty array of color strings';
      }
      return null;
    default:
      return null;
  }
}

/**
 * Validate non-geometry prop values. Returns an error string or null.
 * Geometry is handled by clampUpdateProps.
 */
export function validatePropValue(key: string, value: unknown, type: string): string | null {
  const schema = getEditablePropSchema(type, key);
  if (!schema) return `${key} is not valid on ${type} elements`;

  const schemaErr = validateJsonSchemaSubset(value, schema, key);
  if (schemaErr) return schemaErr;

  return validatePolicyOverlay(key, value);
}

/**
 * Clamp geometry the same way gesture cores do: min size per type; rotate
 * normalized to (-180, 180]. Line `width` is stroke thickness (min 1), not box size.
 */
export function clampUpdateProps(
  type: string,
  props: Record<string, unknown>,
): Record<string, unknown> {
  const out: Record<string, unknown> = { ...props };

  if ('width' in out) {
    if (!isFiniteNumber(out.width)) throw new Error(`width must be a finite number`);
    const width = out.width;
    if (type === 'line') {
      out.width = Math.min(LINE_STROKE_MAX, Math.max(LINE_STROKE_MIN, width));
    } else {
      const clampedWidth = Math.max(minSizeFor(type), width);
      out.width = clampCoord(clampedWidth, 'width');
    }
  }
  if ('height' in out) {
    if (!isFiniteNumber(out.height)) throw new Error(`height must be a finite number`);
    if (type === 'line') throw new Error(`line elements have no height`);
    const height = out.height;
    const clampedHeight = Math.max(minSizeFor(type), height);
    out.height = clampCoord(clampedHeight, 'height');
  }
  if ('left' in out) {
    if (!isFiniteNumber(out.left)) throw new Error(`left must be a finite number`);
    out.left = clampCoord(out.left, 'left');
  }
  if ('top' in out) {
    if (!isFiniteNumber(out.top)) throw new Error(`top must be a finite number`);
    out.top = clampCoord(out.top, 'top');
  }
  if ('rotate' in out) {
    if (type === 'line') throw new Error(`line elements have no rotate`);
    if (!isFiniteNumber(out.rotate)) throw new Error(`rotate must be a finite number`);
    out.rotate = normalizeRotate(out.rotate);
  }
  if ('opacity' in out) {
    if (!isFiniteNumber(out.opacity)) throw new Error(`opacity must be a finite number`);
    out.opacity = Math.min(1, Math.max(0, out.opacity));
  }
  if ('filters' in out) {
    const filters = out.filters as Record<string, string>;
    out.filters = Object.fromEntries(
      Object.entries(filters).map(([key, value]) => {
        const unit = FILTER_UNITS[key];
        const trimmed = value.trim();
        return [key, unit && trimmed.endsWith(unit) ? trimmed.slice(0, -unit.length) : trimmed];
      }),
    );
  }

  return out;
}

function validatePropsKeys(props: Record<string, unknown>): string | null {
  const keys = Object.keys(props);
  if (keys.length === 0) return 'update has empty props';
  for (const key of keys) {
    if (FORBIDDEN_EDIT_PROPS.has(key)) {
      return `prop ${JSON.stringify(key)} is not editable via edit_elements`;
    }
    if (!ALLOWED_EDIT_PROPS.has(key)) {
      return `prop ${JSON.stringify(key)} is out of contract`;
    }
  }
  return null;
}

function enforceGroupCohesion(
  updates: Array<{ id: string; props: Partial<PPTElement> }>,
  inventory: ElementInventoryItem[],
): string | null {
  const byId = new Map(inventory.map((el) => [el.id, el]));
  const updateById = new Map(updates.map((update) => [update.id, update]));
  const targeted = new Set(updates.map((u) => u.id));
  const checkedGroups = new Set<string>();
  for (const id of targeted) {
    const el = byId.get(id);
    if (!el?.groupId || checkedGroups.has(el.groupId)) continue;
    checkedGroups.add(el.groupId);
    const members = inventory.filter((x) => x.groupId === el.groupId);
    const missing = members.filter((member) => !targeted.has(member.id)).map((member) => member.id);
    if (missing.length > 0) {
      return `group ${JSON.stringify(el.groupId)} must be edited as a unit (missing ${missing.map((m) => JSON.stringify(m)).join(', ')})`;
    }

    for (const member of members) {
      const props = updateById.get(member.id)?.props ?? {};
      if ('height' in props || 'rotate' in props || (member.type !== 'line' && 'width' in props)) {
        return `group ${JSON.stringify(el.groupId)} does not support resize or rotate edits`;
      }
    }

    for (const axis of ['left', 'top'] as const) {
      const deltas = members.map((member) => {
        const next = updateById.get(member.id)?.props[axis];
        return (typeof next === 'number' ? next : member[axis]) - member[axis];
      });
      if (deltas.some((delta) => Math.abs(delta - deltas[0]) > GROUP_TRANSLATION_TOLERANCE)) {
        return `group ${JSON.stringify(el.groupId)} must use one rigid translation delta for ${axis}`;
      }
    }
  }
  return null;
}

function contextualProposalError(
  element: ElementInventoryItem,
  props: Record<string, unknown>,
  composedTextVisible?: boolean,
  replacedProps?: ReadonlySet<string>,
): string | null {
  if (!PRO_EDITOR_SUPPORTED_TYPES.has(element.type)) {
    return `${element.type} elements are not editable in the active Pro editor`;
  }
  if (element.type === 'text' && 'vAlign' in props) {
    return 'vAlign is not rendered for text elements in the active Pro editor';
  }
  if (element.type === 'latex' && element.latexRenderMode === 'none') {
    return 'latex element has no renderable HTML or SVG branch';
  }
  if (
    element.type === 'text' &&
    element.hasTextGlyphs === false &&
    Object.keys(props).some((key) => TEXT_GLYPH_PROPS.has(key))
  ) {
    if (composedTextVisible !== true) {
      return 'text glyph chrome is not visible without painted text content';
    }
  }
  const hasIndividuallyEffectiveProp = Object.entries(props).some(([key, value]) =>
    propChangesEffectiveState(element, key, value, replacedProps?.has(key)),
  );
  if (element.type === 'text' && element.hasTextGlyphs === false && hasIndividuallyEffectiveProp) {
    const currentVisible = textBoxPaintVisible(element.style, {});
    const nextVisible = composedTextVisible === true || textBoxPaintVisible(element.style, props);
    if (!currentVisible && !nextVisible) {
      return 'text element has no visible paint before or after the proposed update';
    }
  }
  if (
    (element.type === 'shape' || element.type === 'line' || element.type === 'latex') &&
    hasIndividuallyEffectiveProp &&
    !elementPaintVisible(element, {}) &&
    !elementPaintVisible(element, props)
  ) {
    return `${element.type} element has no visible paint before or after the proposed update`;
  }
  if (
    element.type === 'shape' &&
    !element.hasShapeText &&
    composedTextVisible !== true &&
    Object.keys(props).some((key) => SHAPE_TEXT_CHROME_PROPS.has(key) || key === 'vAlign')
  ) {
    return 'shape text chrome is not visible without a shape label';
  }
  if (element.type === 'latex' && 'color' in props && element.hasInlineLatexColor) {
    return 'inline KaTeX color overrides the latex element color';
  }
  if (
    element.type === 'latex' &&
    element.latexRenderMode !== 'svg' &&
    ('width' in props || 'height' in props)
  ) {
    return 'latex resizing is not rendered consistently across app and package surfaces';
  }
  if (element.type === 'shape' && 'fill' in props && 'gradient' in props) {
    return 'fill and gradient are mutually exclusive shape paint edits';
  }
  if (element.type === 'table' && 'outline' in props) {
    if (element.hasCellBorders) {
      return 'table outline is not consistent across renderers when cells have explicit borders';
    }
    const patch = props.outline as Record<string, unknown>;
    if (patch.style === 'dotted') {
      return 'dotted table outlines are not rendered distinctly from solid outlines';
    }
  }
  if (
    element.type === 'chart' &&
    'lineColor' in props &&
    (element.chartType === 'pie' || element.chartType === 'ring')
  ) {
    return `lineColor is not rendered for ${element.chartType} charts`;
  }
  if (
    element.type === 'chart' &&
    element.hasRenderableChartData === false &&
    Object.keys(props).some(
      (key) => key === 'themeColors' || key === 'textColor' || key === 'lineColor',
    )
  ) {
    return 'chart colors are not visible without a non-empty data series';
  }
  if ('outline' in props) {
    const hasCurrentOutline = isRecord(element.style.outline);
    const current: Record<string, unknown> = hasCurrentOutline
      ? (element.style.outline as Record<string, unknown>)
      : {};
    const patch = props.outline as Record<string, unknown>;
    const next = replacedProps?.has('outline') ? patch : { ...current, ...patch };
    const currentWidth = isFiniteNumber(current.width)
      ? current.width
      : element.type === 'table' && hasCurrentOutline
        ? 1
        : 0;
    const nextWidth = isFiniteNumber(next.width) ? next.width : element.type === 'table' ? 1 : 0;
    if (currentWidth === 0 && nextWidth === 0) {
      return 'outline edit has no visible width';
    }
  }
  if ('radius' in props && element.type === 'image') {
    const clipShape = element.imageClipShape ?? 'rect';
    if (clipShape !== 'rect' && clipShape !== 'roundRect') {
      return `radius is not rendered for image clip ${JSON.stringify(clipShape)}`;
    }
  }
  return null;
}

function visibleColor(value: unknown): boolean {
  return isColorString(value) && canonicalColor(value) !== canonicalColor('transparent');
}

function visibleOutline(
  current: Record<string, unknown>,
  patch: Record<string, unknown> | undefined,
): boolean {
  const outline = patch ? { ...current, ...patch } : current;
  return (
    isFiniteNumber(outline.width) && outline.width > 0 && visibleColor(outline.color ?? '#d14424')
  );
}

function textBoxPaintVisible(
  style: Record<string, unknown>,
  props: Record<string, unknown>,
): boolean {
  const opacity = 'opacity' in props ? props.opacity : (style.opacity ?? 1);
  if (!isFiniteNumber(opacity) || Math.min(1, Math.max(0, opacity)) === 0) return false;
  const fill = 'fill' in props ? props.fill : style.fill;
  const currentOutline = isRecord(style.outline) ? style.outline : {};
  const outlinePatch = isRecord(props.outline) ? props.outline : undefined;
  return visibleColor(fill) || visibleOutline(currentOutline, outlinePatch);
}

function visibleGradient(value: unknown): boolean {
  return (
    isRecord(value) &&
    Array.isArray(value.colors) &&
    value.colors.some((stop) => isRecord(stop) && visibleColor(stop.color))
  );
}

function elementPaintVisible(
  element: ElementInventoryItem,
  props: Record<string, unknown>,
): boolean {
  if (element.type === 'line') {
    const width =
      'width' in props && isFiniteNumber(props.width)
        ? Math.min(LINE_STROKE_MAX, Math.max(LINE_STROKE_MIN, props.width))
        : element.width;
    return (
      width > 0 &&
      (element.lineHasVisiblePath === true || element.lineHasEndpointMarker === true) &&
      visibleColor('color' in props ? props.color : (element.style.color ?? '#333333'))
    );
  }
  if (element.type === 'latex') {
    if (element.latexRenderMode === 'html') return textVisibleWithProposal(element, props) === true;
    return element.latexRenderMode === 'svg'
      ? visibleColor('color' in props ? props.color : element.style.color)
      : false;
  }
  if (element.type !== 'shape') return true;
  const opacity = 'opacity' in props ? props.opacity : (element.style.opacity ?? 1);
  if (!isFiniteNumber(opacity) || Math.min(1, Math.max(0, opacity)) === 0) return false;
  const currentOutline = isRecord(element.style.outline) ? element.style.outline : {};
  const outlinePatch = isRecord(props.outline) ? props.outline : undefined;
  if (
    visibleOutline(currentOutline, outlinePatch) ||
    textVisibleWithProposal(element, props) === true
  ) {
    return true;
  }
  if (!('fill' in props) && !('gradient' in props) && element.hasPattern) return true;
  if ('fill' in props) return visibleColor(props.fill);
  const gradient = 'gradient' in props ? props.gradient : element.style.gradient;
  if (gradient !== undefined) return visibleGradient(gradient);
  return visibleColor(element.style.fill);
}

function currentInventoryValue(element: ElementInventoryItem, key: string): unknown {
  if (key === 'left' || key === 'top' || key === 'width') return element[key];
  if (key === 'height') return element.height;
  if (key === 'rotate') return element.rotate ?? 0;
  if (key === 'radius' && element.type === 'image' && element.style.radius === undefined) {
    return element.imageClipShape === 'roundRect' ? 10 : 0;
  }
  const current = element.style[key];
  if (current !== undefined) return current;
  if (key === 'opacity') return 1;
  if (key === 'flipH' || key === 'flipV' || key === 'fixedRatio' || key === 'vertical') {
    return false;
  }
  if (key === 'wordSpace') return 0;
  if (key === 'paragraphSpace' && (element.type === 'text' || element.type === 'shape')) return 5;
  if (key === 'vAlign' && element.type === 'shape') return 'middle';
  return undefined;
}

function canonicalColor(value: unknown): unknown {
  if (!isColorString(value)) return value;
  const color = tinycolor(String(value));
  return color.getAlpha() === 0 ? 'rgba(0, 0, 0, 0)' : color.toRgbString();
}

function normalizeThemeColors(value: unknown[], count: number): unknown[] {
  if (value.length === 0 || count === 0) return [];
  let colors: unknown[];
  if (value.length >= 10) {
    colors = value;
  } else if (value.length === 1) {
    colors = tinycolor(String(value[0]))
      .analogous(10)
      .map((color) => color.toRgbString());
  } else {
    const supplement = tinycolor(String(value[value.length - 1]))
      .analogous(11 - value.length)
      .map((color) => color.toRgbString());
    colors = [...value.slice(0, -1), ...supplement];
  }
  return colors.slice(0, count).map(canonicalColor);
}

function normalizeFilters(value: unknown): Record<string, unknown> {
  if (!isRecord(value)) return {};
  const normalized: Record<string, unknown> = {};
  for (const [key, raw] of Object.entries(value)) {
    if (typeof raw !== 'string') {
      normalized[key] = raw;
      continue;
    }
    const unit = FILTER_UNITS[key];
    const trimmed = raw.trim();
    const numericText = unit && trimmed.endsWith(unit) ? trimmed.slice(0, -unit.length) : trimmed;
    let numeric = Number(numericText);
    if (!Number.isFinite(numeric)) {
      normalized[key] = raw;
      continue;
    }
    if (key === 'hue-rotate') numeric = ((numeric % 360) + 360) % 360;
    if (numeric !== FILTER_IDENTITY[key]) normalized[key] = numeric;
  }
  return normalized;
}

function normalizeEffectiveValue(
  element: ElementInventoryItem,
  key: string,
  value: unknown,
): unknown {
  if ((key === 'fill' || key === 'colorMask') && value === undefined) {
    return canonicalColor('transparent');
  }
  if (COLOR_STRING_PROPS.has(key)) return canonicalColor(value);
  if (key === 'rotate' && isFiniteNumber(value)) return normalizeRotate(value);
  if (key === 'radius' && isFiniteNumber(value) && element.type === 'image') {
    return Math.min(value, Math.min(element.width, element.height ?? element.width) / 2);
  }
  if (key === 'themeColors' && Array.isArray(value)) {
    return normalizeThemeColors(value, element.chartColorCount ?? value.length);
  }
  if (key === 'filters') return normalizeFilters(value);
  if (key === 'outline') {
    if (!isRecord(value)) return { width: 0 };
    const width = isFiniteNumber(value.width) ? value.width : element.type === 'table' ? 1 : 0;
    if (width === 0) return { width: 0 };
    const defaultColor = element.type === 'table' ? '#000000' : '#d14424';
    const color = canonicalColor(value.color ?? defaultColor);
    if (color === canonicalColor('transparent')) return { width: 0 };
    const style =
      value.style === 'dashed' || (element.type !== 'table' && value.style === 'dotted')
        ? value.style
        : 'solid';
    return {
      width,
      color,
      style,
    };
  }
  if (key === 'shadow') {
    if (!isRecord(value)) return null;
    const color = canonicalColor(value.color);
    if (color === canonicalColor('transparent')) return null;
    return { ...value, color };
  }
  if (key === 'gradient' && isRecord(value) && Array.isArray(value.colors)) {
    const type = value.type;
    const colors = value.colors.map((stop) =>
      isRecord(stop) ? { ...stop, color: canonicalColor(stop.color) } : stop,
    );
    const canonicalColors = colors
      .filter(isRecord)
      .map((stop) => stop.color)
      .filter((color) => color !== undefined);
    const monochrome =
      canonicalColors.length > 0 && canonicalColors.every((color) => color === canonicalColors[0]);
    if (monochrome) {
      return { type: 'solid-gradient', colors: [{ pos: 0, color: canonicalColors[0] }] };
    }
    const rotate =
      type === 'radial'
        ? undefined
        : isFiniteNumber(value.rotate)
          ? ((value.rotate % 360) + 360) % 360
          : value.rotate;
    return {
      ...value,
      ...(type === 'radial' ? { rotate: undefined } : { rotate }),
      colors,
    };
  }
  return value;
}

function propChangesEffectiveState(
  element: ElementInventoryItem,
  key: string,
  value: unknown,
  replace = false,
): boolean {
  if (element.type === 'shape' && (key === 'fill' || key === 'gradient') && element.hasPattern) {
    return true;
  }
  if (key === 'fill' && element.type === 'shape' && element.style.gradient !== undefined) {
    const currentGradient = normalizeEffectiveValue(element, 'gradient', element.style.gradient);
    if (
      isRecord(currentGradient) &&
      currentGradient.type === 'solid-gradient' &&
      Array.isArray(currentGradient.colors) &&
      isRecord(currentGradient.colors[0]) &&
      currentGradient.colors[0].color === canonicalColor(value)
    ) {
      return false;
    }
    return true;
  }
  if (key === 'gradient' && element.type === 'shape' && element.style.gradient === undefined) {
    const nextGradient = normalizeEffectiveValue(element, key, value);
    if (
      isRecord(nextGradient) &&
      nextGradient.type === 'solid-gradient' &&
      Array.isArray(nextGradient.colors) &&
      isRecord(nextGradient.colors[0]) &&
      nextGradient.colors[0].color === normalizeEffectiveValue(element, 'fill', element.style.fill)
    ) {
      return false;
    }
  }
  const current = currentInventoryValue(element, key);
  if (MERGED_STYLE_PROPS.has(key) && isRecord(value) && !replace) {
    const currentRecord = isRecord(current) ? current : {};
    const next = { ...currentRecord, ...value };
    return !deepEqual(
      normalizeEffectiveValue(element, key, current),
      normalizeEffectiveValue(element, key, next),
    );
  }
  return !deepEqual(
    normalizeEffectiveValue(element, key, current),
    normalizeEffectiveValue(element, key, value),
  );
}

/**
 * Validate and coerce model proposals into EditIntents.
 * All-or-nothing: any single bad update refuses the whole batch.
 */
export function mapProposalsToEditIntents(
  proposals: ProposedElementUpdate[],
  inventory: ElementInventoryItem[],
  options: {
    replacedPropsById?: ReadonlyMap<string, ReadonlySet<string>>;
    additionalGroupTargetIds?: ReadonlySet<string>;
  } = {},
): EditElementsGateResult {
  if (!Array.isArray(proposals) || proposals.length === 0) {
    return { ok: false, reason: 'no element updates proposed' };
  }

  const byId = new Map(inventory.map((el) => [el.id, el]));
  const seen = new Set<string>();
  const updates: Array<{ id: string; props: Partial<PPTElement> }> = [];

  for (const proposal of proposals) {
    if (!proposal || typeof proposal !== 'object') {
      return { ok: false, reason: 'malformed update entry' };
    }
    const { id, props } = proposal;
    if (typeof id !== 'string' || !id) {
      return { ok: false, reason: 'update missing element id' };
    }
    if (seen.has(id)) {
      return { ok: false, reason: `duplicate update for element ${JSON.stringify(id)}` };
    }
    seen.add(id);

    const el = byId.get(id);
    if (!el) {
      return { ok: false, reason: `unknown element id ${JSON.stringify(id)}` };
    }
    if (el.lock) {
      return { ok: false, reason: `element ${JSON.stringify(id)} is locked` };
    }
    if (!props || typeof props !== 'object' || Array.isArray(props)) {
      return { ok: false, reason: `malformed props for element ${JSON.stringify(id)}` };
    }
    const replacedProps = options.replacedPropsById?.get(id);

    const keyErr = validatePropsKeys(props);
    if (keyErr) return { ok: false, reason: keyErr };
    for (const [key, value] of Object.entries(props)) {
      const valueErr = validatePropValue(key, value, el.type);
      if (valueErr) return { ok: false, reason: valueErr };
    }

    const composedTextVisible = textVisibleWithProposal(el, props);
    const revealsUnpaintedTextWithDefaultColor = textPropContributesToVisibility(
      el,
      props,
      'defaultColor',
      composedTextVisible,
    );
    if ('defaultColor' in props && el.hasInlineTextColor && !revealsUnpaintedTextWithDefaultColor) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} has inline text color that defaultColor cannot override`,
      };
    }
    if ('defaultFontName' in props && el.hasInlineFontFamily) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} has inline font-family that defaultFontName cannot override`,
      };
    }
    if ('lineHeight' in props && el.hasInlineLineHeight) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} has inline line-height that lineHeight cannot override`,
      };
    }
    if ('wordSpace' in props && el.hasInlineLetterSpacing) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} has inline letter-spacing that wordSpace cannot override`,
      };
    }
    if ('paragraphSpace' in props && el.hasInlineParagraphSpacing) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} has inline margin-bottom that paragraphSpace cannot override`,
      };
    }
    if ('vertical' in props && el.hasInlineWritingMode) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} has inline writing-mode that vertical cannot override`,
      };
    }
    const revealsUnpaintedTextWithShadow = textPropContributesToVisibility(
      el,
      props,
      'shadow',
      composedTextVisible,
    );
    if (
      'shadow' in props &&
      el.type === 'text' &&
      el.hasInlineTextShadow &&
      !revealsUnpaintedTextWithShadow
    ) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} has inline text-shadow that shadow cannot override`,
      };
    }

    const contextErr = contextualProposalError(el, props, composedTextVisible, replacedProps);
    if (contextErr) return { ok: false, reason: contextErr };

    if (el.type === 'text') {
      const vertical = 'vertical' in props ? props.vertical === true : el.style.vertical === true;
      if (vertical && 'width' in props) {
        return {
          ok: false,
          reason: `element ${JSON.stringify(id)} has automatic width in vertical text mode`,
        };
      }
      if (!vertical && 'height' in props) {
        return {
          ok: false,
          reason: `element ${JSON.stringify(id)} has automatic height in horizontal text mode`,
        };
      }
    }

    let clamped: Record<string, unknown>;
    try {
      clamped = clampUpdateProps(el.type, props);
    } catch (err) {
      return {
        ok: false,
        reason: err instanceof Error ? err.message : `invalid geometry for ${JSON.stringify(id)}`,
      };
    }

    if (
      !Object.entries(clamped).some(([key, value]) =>
        propChangesEffectiveState(el, key, value, replacedProps?.has(key)),
      )
    ) {
      return { ok: false, reason: `element ${JSON.stringify(id)} update has no effective change` };
    }

    updates.push({ id, props: clamped as Partial<PPTElement> });
  }

  const groupUpdates = [...updates];
  for (const id of options.additionalGroupTargetIds ?? []) {
    if (!groupUpdates.some((update) => update.id === id)) groupUpdates.push({ id, props: {} });
  }
  const groupErr = enforceGroupCohesion(groupUpdates, inventory);
  if (groupErr) return { ok: false, reason: groupErr };

  if (updates.length === 1) {
    return {
      ok: true,
      intents: [{ type: 'element.update', id: updates[0].id, props: updates[0].props }],
    };
  }
  return {
    ok: true,
    intents: [{ type: 'element.updateMany', updates }],
  };
}

function textVisibleWithProposal(
  element: ElementInventoryItem,
  props: Record<string, unknown>,
): boolean | undefined {
  const source = (element as InternalElementInventoryItem)[TEXT_VISIBILITY_SOURCE];
  if (!source) return undefined;
  return hasVisibleHtmlText(source.content, {
    color: source.colorProp in props ? props[source.colorProp] : source.color,
    opacity: 'opacity' in props ? props.opacity : source.opacity,
    shadow:
      'shadow' in props && isRecord(props.shadow)
        ? (props.shadow as TextVisibilitySource['shadow'])
        : source.shadow,
  });
}

function textPropContributesToVisibility(
  element: ElementInventoryItem,
  props: Record<string, unknown>,
  property: string,
  composedTextVisible: boolean | undefined,
): boolean {
  if (composedTextVisible !== true || !(property in props)) return false;
  const withoutProperty = { ...props };
  delete withoutProperty[property];
  return textVisibleWithProposal(element, withoutProperty) === false;
}

/** Build the model-visible inventory from trusted slide elements. */
export function buildElementInventory(elements: PPTElement[]): ElementInventoryItem[] {
  return elements.map((el) => {
    const style: Record<string, unknown> = {};
    for (const key of ALLOWED_EDIT_PROPS) {
      if (
        key === 'left' ||
        key === 'top' ||
        key === 'width' ||
        key === 'height' ||
        key === 'rotate'
      ) {
        continue;
      }
      if (el.type === 'shape' && (SHAPE_TEXT_CHROME_PROPS.has(key) || key === 'vAlign')) {
        const text = (el as { text?: Record<string, unknown> }).text;
        const mappedKey = key === 'vAlign' ? 'align' : key;
        const v = text?.[mappedKey];
        if (v !== undefined) style[key] = v;
        continue;
      }
      const v = (el as unknown as Record<string, unknown>)[key];
      if (v !== undefined) style[key] = v;
    }
    const label = elementLabel(el);
    const base: ElementInventoryItem = {
      id: el.id,
      type: el.type,
      left: el.left,
      top: el.top,
      width: el.width,
      lock: !!el.lock,
      label,
      style,
    };
    if (typeof el.groupId === 'string' && el.groupId) base.groupId = el.groupId;
    if (el.type === 'image') {
      base.imageClipShape = (el as { clip?: { shape?: string } }).clip?.shape?.trim() || 'rect';
    }
    if (el.type === 'line') {
      const line = el as {
        start?: unknown;
        end?: unknown;
        points?: unknown;
        broken?: unknown;
        broken2?: unknown;
        curve?: unknown;
        cubic?: unknown;
      };
      const start = line.start;
      const end = line.end;
      const validEndpoints =
        Array.isArray(start) && Array.isArray(end) && start.length >= 2 && end.length >= 2;
      const differsFromStart = (point: unknown) =>
        Array.isArray(point) &&
        point.length >= 2 &&
        validEndpoints &&
        (point[0] !== start[0] || point[1] !== start[1]);
      const broken2Visible =
        Array.isArray(line.broken2) &&
        line.broken2.length >= 2 &&
        validEndpoints &&
        (Math.max(Number(start[0]), Number(end[0])) >= Math.max(Number(start[1]), Number(end[1]))
          ? line.broken2[0] !== start[0]
          : line.broken2[1] !== start[1]);
      const controlPathVisible = line.broken
        ? differsFromStart(line.broken)
        : line.broken2
          ? broken2Visible
          : line.curve
            ? differsFromStart(line.curve)
            : line.cubic
              ? Array.isArray(line.cubic) && line.cubic.some(differsFromStart)
              : false;
      base.lineHasVisiblePath =
        validEndpoints && (start[0] !== end[0] || start[1] !== end[1] || controlPathVisible);
      base.lineHasEndpointMarker =
        Array.isArray(line.points) &&
        line.points.some((point) => typeof point === 'string' && point);
    }
    if (el.type === 'shape') {
      const shape = el as {
        pattern?: unknown;
        opacity?: unknown;
        text?: { content?: unknown; defaultColor?: unknown };
      };
      base.hasPattern = !!shape.pattern;
      base.hasShapeText =
        typeof shape.text?.content === 'string' &&
        hasVisibleHtmlText(shape.text.content, {
          color: shape.text.defaultColor,
          opacity: shape.opacity,
        });
      if (typeof shape.text?.content === 'string') {
        Object.defineProperty(base, TEXT_VISIBILITY_SOURCE, {
          value: {
            content: shape.text.content,
            colorProp: 'defaultColor',
            color: shape.text.defaultColor,
            opacity: shape.opacity,
          } satisfies TextVisibilitySource,
        });
      }
    }
    if (el.type === 'latex') {
      const latex = el as { html?: unknown; path?: unknown; viewBox?: unknown; color?: unknown };
      const html = latex.html;
      const hasHtml =
        typeof html === 'string' &&
        hasVisibleHtmlText(html, { color: latex.color, ignorePaint: true });
      const hasPath =
        typeof latex.path === 'string' &&
        latex.path.trim().length > 0 &&
        Array.isArray(latex.viewBox) &&
        latex.viewBox.length >= 2 &&
        latex.viewBox.every((value) => isFiniteNumber(value) && value > 0);
      base.latexRenderMode =
        typeof html === 'string' && html.length > 0
          ? hasHtml
            ? 'html'
            : 'none'
          : hasPath
            ? 'svg'
            : 'none';
      base.hasRenderableLatex = base.latexRenderMode !== 'none';
      if (typeof html === 'string') {
        Object.defineProperty(base, TEXT_VISIBILITY_SOURCE, {
          value: {
            content: html,
            colorProp: 'color',
            color: latex.color,
          } satisfies TextVisibilitySource,
        });
        const inline = collectInlineStyleProperties(html);
        base.hasInlineLatexColor =
          inline.has('all') || inline.has('color') || inline.has('-webkit-text-fill-color');
      }
    }
    if (el.type === 'table') {
      const data = (el as { data?: unknown }).data;
      base.hasCellBorders =
        Array.isArray(data) &&
        data.some(
          (row) =>
            Array.isArray(row) &&
            row.some((cell) => {
              if (!isRecord(cell) || !isRecord(cell.borders)) return false;
              const borders = cell.borders;
              return ['top', 'bottom', 'left', 'right'].some((side) => !!borders[side]);
            }),
        );
    }
    if (el.type === 'chart') {
      const chart = el as { chartType?: unknown; data?: { series?: unknown } };
      const chartType = chart.chartType;
      if (typeof chartType === 'string') base.chartType = chartType;
      const series = chart.data?.series;
      const seriesArray: unknown[] = Array.isArray(series) ? series : [];
      base.hasRenderableChartData =
        seriesArray.length > 0 &&
        (chartType === 'pie' || chartType === 'ring'
          ? Array.isArray(seriesArray[0]) && seriesArray[0].length > 0
          : true);
      base.chartColorCount =
        chartType === 'pie' || chartType === 'ring'
          ? Array.isArray(seriesArray[0])
            ? seriesArray[0].length
            : 0
          : chartType === 'scatter'
            ? Array.isArray(seriesArray[0]) && seriesArray[0].length > 0
              ? 1
              : 0
            : seriesArray.length === 1 &&
                Array.isArray(seriesArray[0]) &&
                seriesArray[0].length === 0
              ? 0
              : seriesArray.length;
    }
    const textContent =
      el.type === 'text'
        ? (el as { content?: unknown }).content
        : el.type === 'shape'
          ? (el as { text?: { content?: unknown } }).text?.content
          : undefined;
    if (typeof textContent === 'string') {
      if (el.type === 'text') {
        const text = el as {
          defaultColor?: unknown;
          opacity?: unknown;
          shadow?: { h?: unknown; v?: unknown; blur?: unknown; color?: unknown };
        };
        const visibilityOptions = {
          color: text.defaultColor,
          opacity: text.opacity,
          shadow: text.shadow,
        };
        base.hasTextGlyphs = hasVisibleHtmlText(textContent, visibilityOptions);
        base.hasTextContent = hasVisibleHtmlText(textContent, {
          ...visibilityOptions,
          ignorePaint: true,
        });
        Object.defineProperty(base, TEXT_VISIBILITY_SOURCE, {
          value: {
            content: textContent,
            colorProp: 'defaultColor',
            ...visibilityOptions,
          } satisfies TextVisibilitySource,
        });
      }
      const inline = collectInlineStyleProperties(textContent);
      const has = (...properties: string[]) => properties.some((property) => inline.has(property));
      if (has('color', '-webkit-text-fill-color')) base.hasInlineTextColor = true;
      if (has('font-family', 'font')) base.hasInlineFontFamily = true;
      if (has('line-height', 'font')) base.hasInlineLineHeight = true;
      if (has('letter-spacing')) base.hasInlineLetterSpacing = true;
      if (has('margin-bottom', 'margin', 'margin-block', 'margin-block-end', '--paragraphSpace')) {
        base.hasInlineParagraphSpacing = true;
      }
      if (has('writing-mode', '-webkit-writing-mode')) base.hasInlineWritingMode = true;
      if (has('text-shadow')) base.hasInlineTextShadow = true;
    }
    if (el.type !== 'line') {
      base.height = (el as { height: number }).height;
      base.rotate = (el as { rotate: number }).rotate;
    }
    return base;
  });
}

function hasVisibleHtmlText(
  content: string,
  options: {
    color?: unknown;
    opacity?: unknown;
    shadow?: { h?: unknown; v?: unknown; blur?: unknown; color?: unknown };
    ignorePaint?: boolean;
  } = {},
): boolean {
  type VisibilityState = {
    hidden: boolean;
    visibilityHidden: boolean;
    fontSizeZero: boolean;
    colorTransparent: boolean;
    textFillTransparent?: boolean;
    textShadowValue?: string;
  };
  const rootColorTransparent =
    typeof options.color === 'string' ? (cssColorTransparency(options.color) ?? false) : false;
  const rootShadow = options.shadow;
  const rootShadowValue =
    rootShadow &&
    isFiniteNumber(rootShadow.h) &&
    isFiniteNumber(rootShadow.v) &&
    isFiniteNumber(rootShadow.blur) &&
    typeof rootShadow.color === 'string'
      ? `${rootShadow.h}px ${rootShadow.v}px ${rootShadow.blur}px ${rootShadow.color}`
      : undefined;
  const rootState: VisibilityState = {
    hidden:
      !options.ignorePaint && isFiniteNumber(options.opacity)
        ? Math.min(1, Math.max(0, options.opacity)) === 0
        : false,
    visibilityHidden: false,
    fontSizeZero: false,
    colorTransparent: rootColorTransparent,
    textFillTransparent: undefined,
    textShadowValue: rootShadowValue,
  };
  const visibilityStack: VisibilityState[] = [];
  let visibleText = '';
  const tokens = tokenizeHtml(content);
  const voidTags = new Set([
    'area',
    'base',
    'br',
    'col',
    'embed',
    'hr',
    'img',
    'input',
    'link',
    'meta',
    'source',
    'track',
    'wbr',
  ]);
  for (const token of tokens) {
    if (!token.startsWith('<')) {
      const state = visibilityStack.at(-1) ?? rootState;
      const transparentPaint =
        state?.textFillTransparent === true ||
        (state?.textFillTransparent === undefined && state?.colorTransparent);
      const shadowVisible = state?.textShadowValue
        ? textShadowIsVisible(state.textShadowValue, state.colorTransparent)
        : false;
      if (
        !state?.hidden &&
        !state?.visibilityHidden &&
        !state?.fontSizeZero &&
        (options.ignorePaint || !transparentPaint || shadowVisible)
      ) {
        visibleText += token;
      }
      continue;
    }
    if (/^<\s*[!/]/.test(token)) {
      if (/^<\s*\//.test(token)) visibilityStack.pop();
      continue;
    }
    const tag = token.match(/^<\s*([\w:-]+)/)?.[1]?.toLowerCase();
    if (!tag) continue;
    const parent = visibilityStack.at(-1) ?? rootState;
    const attributes = htmlAttributeVisibility(token);
    const colorTransparent = attributes.colorTransparent ?? parent.colorTransparent;
    const state: VisibilityState = {
      hidden: parent.hidden || attributes.hidden,
      visibilityHidden: attributes.visibilityHidden ?? parent.visibilityHidden,
      fontSizeZero: attributes.fontSizeZero ?? parent.fontSizeZero,
      colorTransparent,
      textFillTransparent: attributes.resetTextFill
        ? undefined
        : (attributes.textFillTransparent ?? parent.textFillTransparent),
      textShadowValue: attributes.textShadowValue ?? parent.textShadowValue,
    };
    if (!token.endsWith('/>') && !voidTags.has(tag)) visibilityStack.push(state);
  }
  return (
    visibleText
      .replace(/<[^>]*>/g, ' ')
      .replace(/&(?:nbsp|#160|#x0*a0);/gi, ' ')
      .replace(/\s+/g, '').length > 0
  );
}

function tokenizeHtml(content: string): string[] {
  const tokens: string[] = [];
  let index = 0;
  while (index < content.length) {
    if (content[index] !== '<') {
      const next = content.indexOf('<', index);
      const end = next < 0 ? content.length : next;
      tokens.push(content.slice(index, end));
      index = end;
      continue;
    }
    let end = index + 1;
    let quote = '';
    while (end < content.length) {
      const char = content[end];
      if (quote) {
        if (char === quote) quote = '';
      } else if (char === '"' || char === "'") {
        quote = char;
      } else if (char === '>') {
        end++;
        break;
      }
      end++;
    }
    tokens.push(content.slice(index, end));
    index = end;
  }
  return tokens;
}

function htmlAttributeVisibility(tag: string): {
  hidden: boolean;
  visibilityHidden?: boolean;
  fontSizeZero?: boolean;
  colorTransparent?: boolean;
  textFillTransparent?: boolean;
  resetTextFill?: boolean;
  textShadowValue?: string;
} {
  const hiddenAttribute = /\shidden(?:\s*=\s*(?:["'][^"']*["']|[^\s>]+))?(?=\s|\/?>)/i.test(tag);
  const className = tag.match(/\bclass\s*=\s*(["'])(.*?)\1/i)?.[2] ?? '';
  const classNames = className.split(/\s+/);
  let displayHidden = classNames.includes('hidden');
  let opacityHidden = false;
  let visibilityHidden = classNames.includes('invisible')
    ? true
    : classNames.includes('visible')
      ? false
      : undefined;
  let fontSizeZero: boolean | undefined;
  const style = tag.match(/\bstyle\s*=\s*(["'])(.*?)\1/i)?.[2];
  let colorTransparent: boolean | undefined;
  let textFillTransparent: boolean | undefined;
  let resetTextFill = false;
  let textShadowValue: string | undefined;
  if (!style) return { hidden: hiddenAttribute || displayHidden, visibilityHidden };
  for (const [property, value] of winningInlineDeclarations(style)) {
    if (property === 'display') {
      if (value === 'none') displayHidden = true;
      else if (value === 'revert-layer') {
        // Preserve the lower author-layer class winner.
      } else if (isValidVisibleDisplayValue(value)) displayHidden = false;
    }
    if (property === 'visibility') {
      if (value === 'hidden' || value === 'collapse') visibilityHidden = true;
      else if (value === 'visible' || value === 'initial') {
        visibilityHidden = false;
      } else if (value === 'inherit' || value === 'unset' || value === 'revert') {
        visibilityHidden = undefined;
      } else if (value === 'revert-layer') {
        // Preserve the lower author-layer class winner.
      }
    }
    if (property === 'opacity') {
      const opacity = value.match(/^([+-]?(?:\d+(?:\.\d*)?|\.\d+))%?$/);
      opacityHidden = opacity
        ? Number(opacity[1]) === 0
        : /^(?:initial|inherit|unset|revert|revert-layer)$/.test(value)
          ? false
          : true;
    }
    if (property === 'font-size') {
      const size = value.match(/^([+-]?(?:\d+(?:\.\d*)?|\.\d+))(?:px|pt|pc|em|rem|%)?$/i);
      if (size) fontSizeZero = Number(size[1]) === 0;
      else if (value === 'initial') fontSizeZero = false;
      else if (
        value === 'inherit' ||
        value === 'unset' ||
        value === 'revert' ||
        value === 'revert-layer'
      ) {
        fontSizeZero = undefined;
      } else {
        fontSizeZero = true;
      }
    }
    if (property === 'color') {
      colorTransparent = value === 'initial' ? false : cssColorTransparency(value);
      if (
        value === 'inherit' ||
        value === 'unset' ||
        value === 'revert' ||
        value === 'revert-layer' ||
        value === 'currentcolor'
      ) {
        colorTransparent = undefined;
      } else if (colorTransparent === undefined) {
        colorTransparent = true;
      }
    }
    if (property === '-webkit-text-fill-color') {
      if (value === 'initial' || value === 'currentcolor') {
        resetTextFill = true;
        textFillTransparent = undefined;
      } else if (
        value === 'inherit' ||
        value === 'unset' ||
        value === 'revert' ||
        value === 'revert-layer'
      ) {
        resetTextFill = false;
        textFillTransparent = undefined;
      } else {
        textFillTransparent = cssColorTransparency(value) ?? true;
      }
    }
    if (property === 'text-shadow') {
      textShadowValue =
        value === 'initial' || value === 'none'
          ? 'none'
          : value === 'inherit' ||
              value === 'unset' ||
              value === 'revert' ||
              value === 'revert-layer'
            ? undefined
            : value;
    }
  }
  return {
    hidden: hiddenAttribute || displayHidden || opacityHidden,
    visibilityHidden,
    fontSizeZero,
    colorTransparent,
    textFillTransparent,
    resetTextFill,
    textShadowValue,
  };
}

function winningInlineDeclarations(style: string): Map<string, string> {
  const allProperties = [
    'display',
    'opacity',
    'visibility',
    'font-size',
    'color',
    '-webkit-text-fill-color',
    'text-shadow',
    'font-family',
    'line-height',
    'letter-spacing',
    'margin',
    'margin-bottom',
    'margin-block',
    'margin-block-end',
    'writing-mode',
    '-webkit-writing-mode',
  ];
  const cssWideValues = new Set(['initial', 'inherit', 'unset', 'revert', 'revert-layer']);
  const winners = new Map<string, { value: string; important: boolean }>();
  for (const declaration of style.split(';')) {
    const colon = declaration.indexOf(':');
    if (colon < 0) continue;
    const property = declaration.slice(0, colon).trim().toLowerCase();
    if (!property) continue;
    const rawValue = declaration.slice(colon + 1).trim();
    const important = /!important\s*$/i.test(rawValue);
    const value = rawValue
      .replace(/!important\s*$/i, '')
      .trim()
      .toLowerCase();
    if (property !== 'all' && !isValidTrackedCssDeclaration(property, value, cssWideValues)) {
      continue;
    }
    const targets: Array<[string, string]> =
      property === 'all'
        ? cssWideValues.has(value)
          ? allProperties.map((target) => [target, value])
          : []
        : property === 'font'
          ? [
              ['font-size', fontShorthandSize(value) ?? value],
              ['font-family', value],
              ['line-height', value],
            ]
          : [[property, value]];
    for (const [target, targetValue] of targets) {
      const current = winners.get(target);
      if (!current || important || !current.important) {
        winners.set(target, { value: targetValue, important });
      }
    }
  }
  return new Map(Array.from(winners, ([property, winner]) => [property, winner.value]));
}

function isValidTrackedCssDeclaration(
  property: string,
  value: string,
  cssWideValues: ReadonlySet<string>,
): boolean {
  if (cssWideValues.has(value)) return true;
  if (property === 'display') return value === 'none' || isValidVisibleDisplayValue(value);
  if (property === 'visibility') return /^(?:visible|hidden|collapse)$/.test(value);
  if (property === 'opacity') {
    return (
      /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)%?$/.test(value) ||
      /^(?:calc|min|max|clamp|var)\(.+\)$/.test(value)
    );
  }
  if (property === 'font-size') return fontSizeValue(value) !== undefined;
  if (property === 'font') return fontShorthandSize(value) !== undefined;
  if (property === 'color' || property === '-webkit-text-fill-color') {
    return (
      value === 'currentcolor' ||
      isColorString(value) ||
      cssColorTransparency(value) !== undefined ||
      /^(?:color|color-mix|lab|lch|oklab|oklch|var)\(.+\)$/.test(value)
    );
  }
  if (property === 'writing-mode' || property === '-webkit-writing-mode') {
    return /^(?:horizontal-tb|vertical-rl|vertical-lr|sideways-rl|sideways-lr)$/.test(value);
  }
  if (property === 'text-shadow') {
    return value === 'none' || isValidTextShadowValue(value);
  }
  return value.length > 0;
}

function fontSizeValue(value: string): string | undefined {
  return /^(?:xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large|larger|smaller|0|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:px|pt|pc|in|cm|mm|q|em|rem|ex|ch|lh|rlh|vw|vh|vmin|vmax|%)|(?:calc|min|max|clamp|var)\(.+\))$/.test(
    value,
  )
    ? value
    : undefined;
}

function fontShorthandSize(value: string): string | undefined {
  if (/^(?:initial|inherit|unset|revert|revert-layer)$/.test(value)) return value;
  if (/^(?:caption|icon|menu|message-box|small-caption|status-bar)$/.test(value)) return 'initial';
  const match = value.match(
    /(?:^|\s)(xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large|larger|smaller|0|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:px|pt|pc|in|cm|mm|q|em|rem|ex|ch|lh|rlh|vw|vh|vmin|vmax|%))(?=\s|\/)/,
  );
  return match?.[1];
}

function isValidVisibleDisplayValue(value: string): boolean {
  if (
    /^(?:block|inline|run-in|flow|flow-root|table|flex|grid|ruby|list-item|contents|inline-(?:block|table|flex|grid)|table-(?:row-group|header-group|footer-group|row|cell|column-group|column|caption)|ruby-(?:base|text|base-container|text-container)|initial|inherit|unset|revert)$/i.test(
      value,
    )
  ) {
    return true;
  }
  const tokens = value.split(/\s+/);
  const listItem = tokens.at(-1) === 'list-item';
  if (listItem) tokens.pop();
  const outside = new Set(['block', 'inline', 'run-in']);
  const inside = new Set(['flow', 'flow-root', 'table', 'flex', 'grid', 'ruby']);
  const validPair =
    (tokens.length === 1 && (outside.has(tokens[0]) || inside.has(tokens[0]))) ||
    (tokens.length === 2 && outside.has(tokens[0]) && inside.has(tokens[1]));
  if (!listItem) return validPair;
  const listInside = new Set(['flow', 'flow-root']);
  return (
    tokens.length === 0 ||
    (tokens.length === 1 && (outside.has(tokens[0]) || listInside.has(tokens[0]))) ||
    (tokens.length === 2 && outside.has(tokens[0]) && listInside.has(tokens[1]))
  );
}

function isValidTextShadowValue(value: string): boolean {
  if (/^var\(.+\)$/.test(value)) return true;
  return splitCssList(value).every((layer) => {
    let lengthCount = 0;
    let colorCount = 0;
    for (const token of splitCssTokens(layer.trim())) {
      if (
        token === '0' ||
        /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:px|pt|pc|in|cm|mm|q|em|rem|ex|ch|vw|vh|vmin|vmax)$/.test(
          token,
        ) ||
        /^(?:calc|min|max|clamp)\(.+\)$/.test(token)
      ) {
        lengthCount++;
        continue;
      }
      if (
        token === 'currentcolor' ||
        isColorString(token) ||
        cssColorTransparency(token) !== undefined ||
        /^(?:color|color-mix|lab|lch|oklab|oklch|var)\(.+\)$/.test(token)
      ) {
        colorCount++;
        if (colorCount > 1) return false;
        continue;
      }
      return false;
    }
    return lengthCount >= 2 && lengthCount <= 3;
  });
}

function splitCssTokens(value: string): string[] {
  const tokens: string[] = [];
  let depth = 0;
  let start = 0;
  for (let index = 0; index <= value.length; index++) {
    const char = value[index];
    if (char === '(') depth++;
    else if (char === ')') depth = Math.max(0, depth - 1);
    if ((index === value.length || /\s/.test(char)) && depth === 0) {
      if (index > start) tokens.push(value.slice(start, index));
      start = index + 1;
    }
  }
  return tokens;
}

function cssColorTransparency(value: string): boolean | undefined {
  if (isColorString(value)) return tinycolor(value).getAlpha() === 0;
  const alpha =
    value.match(/^(?:rgba|hsla)\([^)]*(?:,|\/)\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))%\s*\)$/i) ??
    value.match(/^[a-z][\w-]*\([^)]*\/\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))%?\s*\)$/i);
  if (alpha) return Number(alpha[1]) === 0;
  return undefined;
}

function textShadowIsVisible(value: string, currentColorTransparent: boolean): boolean {
  const normalized = value.trim().toLowerCase();
  if (normalized === 'none' || normalized === 'initial' || normalized.startsWith('revert')) {
    return false;
  }
  if (/\b(?:var|color|color-mix|lab|lch|oklab|oklch)\(/.test(normalized)) return false;
  for (const shadow of splitCssList(value)) {
    const candidates = shadow.match(/(?:rgba?|hsla?)\([^)]*\)|#[0-9a-f]{3,8}|\b[a-z]+\b/gi) ?? [];
    let foundColor = false;
    let layerVisible = false;
    for (const candidate of candidates) {
      const lower = candidate.toLowerCase();
      if (lower === 'currentcolor') {
        foundColor = true;
        layerVisible ||= !currentColorTransparent;
        continue;
      }
      const transparency = cssColorTransparency(candidate);
      if (!isColorString(candidate) && transparency === undefined) continue;
      if (
        !lower.startsWith('rgb') &&
        !lower.startsWith('hsl') &&
        !lower.startsWith('#') &&
        !Object.hasOwn(tinycolor.names, lower) &&
        lower !== 'transparent'
      ) {
        continue;
      }
      foundColor = true;
      layerVisible ||= transparency === false;
    }
    if (layerVisible || (!foundColor && !currentColorTransparent)) return true;
  }
  return false;
}

function splitCssList(value: string): string[] {
  const items: string[] = [];
  let depth = 0;
  let start = 0;
  for (let index = 0; index < value.length; index++) {
    const char = value[index];
    if (char === '(') depth++;
    else if (char === ')') depth = Math.max(0, depth - 1);
    else if (char === ',' && depth === 0) {
      items.push(value.slice(start, index));
      start = index + 1;
    }
  }
  items.push(value.slice(start));
  return items;
}

function collectInlineStyleProperties(content: string): Set<string> {
  const properties = new Set<string>();
  const styleAttribute = /\bstyle\s*=\s*(["'])(.*?)\1/gi;
  for (const match of content.matchAll(styleAttribute)) {
    for (const [property, value] of winningInlineDeclarations(match[2])) {
      const inheritsElementValue =
        value === 'inherit' || value === 'unset' || value === 'revert' || value === 'revert-layer';
      if (
        inheritsElementValue &&
        [
          'color',
          '-webkit-text-fill-color',
          'font-family',
          'font',
          'line-height',
          'letter-spacing',
          'writing-mode',
          '-webkit-writing-mode',
          'text-shadow',
        ].includes(property)
      ) {
        continue;
      }
      if (
        (property === 'color' && value === 'currentcolor') ||
        (property === '-webkit-text-fill-color' &&
          (value === 'initial' || value === 'currentcolor'))
      ) {
        continue;
      }
      properties.add(property);
    }
    for (const declaration of match[2].split(';')) {
      const colon = declaration.indexOf(':');
      if (colon < 0) continue;
      const property = declaration.slice(0, colon).trim();
      if (property.startsWith('--')) properties.add(property);
    }
  }
  return properties;
}

/** Stable snapshot of the model-visible mutable state used for apply-time drift checks. */
export function elementInventoryFingerprint(element: PPTElement): string {
  const item = buildElementInventory([element])[0];
  return JSON.stringify({ item, applyDependencies: elementApplyDependencies(element) });
}

/** Stable snapshot of every prompt-visible element, including order and membership. */
export function elementInventorySnapshotFingerprint(elements: PPTElement[]): string {
  const inventory = buildElementInventory(elements);
  return JSON.stringify(
    inventory.map((item, index) => ({
      item,
      applyDependencies: elementApplyDependencies(elements[index]),
    })),
  );
}

function elementApplyDependencies(element: PPTElement): unknown {
  if (element.type === 'text') {
    return { content: (element as { content?: unknown }).content };
  }
  if (element.type === 'shape') {
    const shape = element as {
      pattern?: unknown;
      pathFormula?: unknown;
      keypoints?: unknown;
      text?: { content?: unknown };
    };
    return {
      pattern: shape.pattern,
      pathFormula: shape.pathFormula,
      keypoints: shape.keypoints,
      textContent: shape.text?.content,
    };
  }
  if (element.type === 'latex') {
    return { html: (element as { html?: unknown }).html };
  }
  if (element.type === 'table') {
    const table = element as {
      data?: unknown;
      cellMinHeight?: unknown;
      rowHeights?: unknown;
    };
    return {
      rowCount: Array.isArray(table.data) ? table.data.length : undefined,
      cellMinHeight: table.cellMinHeight,
      rowHeights: table.rowHeights,
    };
  }
  return undefined;
}

function elementLabel(el: PPTElement): string {
  if (typeof el.name === 'string' && el.name.trim()) return el.name.trim().slice(0, 80);
  const e = el as {
    type: string;
    content?: unknown;
    text?: { content?: unknown };
    textType?: string;
  };
  if (e.type === 'text' && typeof e.content === 'string') {
    const plain = e.content
      .replace(/<[^>]*>/g, ' ')
      .replace(/\s+/g, ' ')
      .trim();
    if (plain) return plain.slice(0, 80);
    if (e.textType) return e.textType;
  }
  if (e.type === 'shape' && typeof e.text?.content === 'string') {
    const plain = e.text.content
      .replace(/<[^>]*>/g, ' ')
      .replace(/\s+/g, ' ')
      .trim();
    if (plain) return plain.slice(0, 80);
  }
  return e.type;
}

/** Collect target element ids from a batch of EditIntents. */
export function collectIntentTargetIds(intents: EditIntent[]): string[] {
  const ids: string[] = [];
  for (const intent of intents) {
    if (intent.type === 'element.update') ids.push(intent.id);
    else if (intent.type === 'element.updateMany') {
      for (const u of intent.updates) ids.push(u.id);
    } else if (intent.type === 'element.removeProps') {
      ids.push(intent.id);
    } else if (intent.type === 'text.updateContent') {
      ids.push(intent.id);
    }
  }
  return ids;
}

/**
 * Apply-time revalidation against the live slide content.
 * Ensures the batch is still fully applicable (ids present, unlocked, group-cohesive).
 */
export function revalidateIntentsAgainstElements(
  elements: PPTElement[],
  intents: EditIntent[],
  targetElementTypes?: Record<string, string>,
  targetElementFingerprints?: Record<string, string>,
): EditElementsGateResult {
  const inventory = buildElementInventory(elements);
  const ids = collectIntentTargetIds(intents);
  if (ids.length === 0) return { ok: false, reason: 'no element updates proposed' };

  const byId = new Map(inventory.map((el) => [el.id, el]));
  for (const id of ids) {
    const el = byId.get(id);
    if (!el) return { ok: false, reason: `unknown element id ${JSON.stringify(id)}` };
    if (el.lock) return { ok: false, reason: `element ${JSON.stringify(id)} is locked` };
    const expectedType = targetElementTypes?.[id];
    if (expectedType && el.type !== expectedType) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} changed type from ${expectedType} to ${el.type}`,
      };
    }
    const expectedFingerprint = targetElementFingerprints?.[id];
    const liveElement = elements.find((item) => item.id === id);
    if (
      expectedFingerprint &&
      liveElement &&
      elementInventoryFingerprint(liveElement) !== expectedFingerprint
    ) {
      return {
        ok: false,
        reason: `element ${JSON.stringify(id)} changed while the edit was being prepared`,
      };
    }
  }
  const groupUpdatesById = new Map<string, Record<string, unknown>>();
  const includeGroupTarget = (id: string, props: Record<string, unknown> = {}) => {
    groupUpdatesById.set(id, { ...groupUpdatesById.get(id), ...props });
  };
  for (const intent of intents) {
    if (intent.type === 'element.update') {
      includeGroupTarget(intent.id, intent.props as Record<string, unknown>);
    } else if (intent.type === 'element.updateMany') {
      for (const update of intent.updates) {
        includeGroupTarget(update.id, update.props as Record<string, unknown>);
      }
    } else if (intent.type === 'element.removeProps' || intent.type === 'text.updateContent') {
      includeGroupTarget(intent.id);
    }
  }
  const groupErr = enforceGroupCohesion(
    [...groupUpdatesById].map(([id, props]) => ({ id, props: props as Partial<PPTElement> })),
    inventory,
  );
  if (groupErr) return { ok: false, reason: groupErr };
  return { ok: true, intents };
}