@wootsup/yt-builder-mcp 1.12.0 → 2.1.0

package/dist/tools/elements/layout-hierarchy-rules.d.ts

@@ -1,62 +0,0 @@
-/**
- * Layout hierarchy grammar — TypeScript mirror of the PHP
- * `WootsUp\BuilderMcp\Elements\LayoutHierarchyRules` constant.
- *
- * YOOtheme Pro renders a layout tree with a FIXED structural skeleton:
- *
- *     root (layout) ⊃ section ⊃ row ⊃ column ⊃ {content | container}
- *
- * Content elements hung directly on the root / in a bare section / in a
- * bare row do NOT render. This grammar (derived from REAL ab-Werk layouts —
- * live-dumped from joomla-dev5 article:2 "The Club", YT 5.0.22) is the
- * single source of truth shared by:
- *   • the PHP per-element + bulk guards (server-side enforcement)
- *   • the `scaffold_section` tool (builds a VALID section→row→column hull)
- *
- * Conservatism contract: REJECT ONLY what is positively known invalid (a
- * child not allowed under a STRICT parent — section/row/root). Every other
- * parent (column, fragment, multi-item containers, unknown 3rd-party) is
- * PERMISSIVE. A false-positive that blocks a legitimate layout is strictly
- * worse than a let-through edge case.
- *
- * The PHP and TS tables MUST stay in lock-step — both files carry a
- * pin-test that fails if the grammar drifts.
- *
- * @license MIT
- */
-/**
- * The ONLY element-type allowed as a DIRECT child of the layout root.
- * Live-verified: every root child on article:2 is a `section`.
- */
-export declare const ROOT_ALLOWED: readonly string[];
-/**
- * STRICT structural parents and their EXHAUSTIVE allowed-child set.
- * `column` is deliberately ABSENT — it is the permissive content host.
- */
-export declare const STRICT_PARENTS: Readonly<Record<string, readonly string[]>>;
-/**
- * Return the exhaustive allowed-child list for `parentType`, or null when
- * `parentType` is NOT a strict structural parent (= permissive).
- */
-export declare function allowedChildrenOf(parentType: string): readonly string[] | null;
-/**
- * Is `childType` a valid DIRECT child of the layout root? Permissive for the
- * empty type and for unknown / fragment types.
- */
-export declare function isAllowedRootChild(childType: string): boolean;
-/**
- * Is `childType` a valid child of `parentType`? Strict parents enforce
- * their allow-list; every other parent is permissive.
- */
-export declare function isAllowedChild(parentType: string, childType: string): boolean;
-/** Is `type` one of the STRICT structural parents (section / row)? */
-export declare function isStructuralParent(type: string): boolean;
-/**
- * Is `childType` a type the STATIC grammar can positively reason about WITHOUT
- * the live YT element-registry? True for the closed grammar (`section` + every
- * KNOWN-non-section type); false for unknown / 3rd-party / `fragment` types
- * (which stay degrade-permissive). Mirror of the PHP
- * `LayoutHierarchyRules::isStaticallyDecidableChild`.
- */
-export declare function isStaticallyDecidableChild(childType: string): boolean;
-//# sourceMappingURL=layout-hierarchy-rules.d.ts.map

package/dist/tools/elements/layout-hierarchy-rules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout-hierarchy-rules.d.ts","sourceRoot":"","sources":["../../../src/tools/elements/layout-hierarchy-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA+B,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAGrE,CAAC;AAEH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,CAI9E;AAgED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAQ7D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAM7E;AAED,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAQrE"}

package/dist/tools/elements/layout-hierarchy-rules.js

@@ -1,154 +0,0 @@
-/**
- * Layout hierarchy grammar — TypeScript mirror of the PHP
- * `WootsUp\BuilderMcp\Elements\LayoutHierarchyRules` constant.
- *
- * YOOtheme Pro renders a layout tree with a FIXED structural skeleton:
- *
- *     root (layout) ⊃ section ⊃ row ⊃ column ⊃ {content | container}
- *
- * Content elements hung directly on the root / in a bare section / in a
- * bare row do NOT render. This grammar (derived from REAL ab-Werk layouts —
- * live-dumped from joomla-dev5 article:2 "The Club", YT 5.0.22) is the
- * single source of truth shared by:
- *   • the PHP per-element + bulk guards (server-side enforcement)
- *   • the `scaffold_section` tool (builds a VALID section→row→column hull)
- *
- * Conservatism contract: REJECT ONLY what is positively known invalid (a
- * child not allowed under a STRICT parent — section/row/root). Every other
- * parent (column, fragment, multi-item containers, unknown 3rd-party) is
- * PERMISSIVE. A false-positive that blocks a legitimate layout is strictly
- * worse than a let-through edge case.
- *
- * The PHP and TS tables MUST stay in lock-step — both files carry a
- * pin-test that fails if the grammar drifts.
- *
- * @license MIT
- */
-/**
- * The ONLY element-type allowed as a DIRECT child of the layout root.
- * Live-verified: every root child on article:2 is a `section`.
- */
-export const ROOT_ALLOWED = Object.freeze(['section']);
-/**
- * STRICT structural parents and their EXHAUSTIVE allowed-child set.
- * `column` is deliberately ABSENT — it is the permissive content host.
- */
-export const STRICT_PARENTS = Object.freeze({
-    section: Object.freeze(['row']),
-    row: Object.freeze(['column']),
-});
-/**
- * Return the exhaustive allowed-child list for `parentType`, or null when
- * `parentType` is NOT a strict structural parent (= permissive).
- */
-export function allowedChildrenOf(parentType) {
-    return Object.prototype.hasOwnProperty.call(STRICT_PARENTS, parentType)
-        ? (STRICT_PARENTS[parentType] ?? null)
-        : null;
-}
-/**
- * The closed set of KNOWN element-types that are NOT a `section` and are
- * therefore invalid as a DIRECT root child. `fragment` is DELIBERATELY
- * excluded (YT5 permissive wrapper). Built from the inner structural types,
- * the canonical content leaves, and the multi-item containers + their items.
- */
-const KNOWN_NON_SECTION_TYPES = new Set([
-    // Inner structural types — never valid on the root.
-    'row',
-    'column',
-    'layout',
-    // Canonical content leaves (YT 4.5.33 built-ins).
-    'text',
-    'headline',
-    'image',
-    'html',
-    'icon',
-    'alert',
-    'code',
-    'countdown',
-    'divider',
-    'overlay',
-    'panel',
-    'quotation',
-    'totop',
-    'video',
-    'spacer',
-    // Multi-item containers + their `*_item` children (mirrors ItemContainerMap).
-    'accordion',
-    'accordion_item',
-    'button',
-    'button_item',
-    'description_list',
-    'description_list_item',
-    'gallery',
-    'gallery_item',
-    'grid',
-    'grid_item',
-    'list',
-    'list_item',
-    'map',
-    'map_item',
-    'nav',
-    'nav_item',
-    'overlay-slider',
-    'overlay-slider_item',
-    'panel-slider',
-    'panel-slider_item',
-    'popover',
-    'popover_item',
-    'slideshow',
-    'slideshow_item',
-    'social',
-    'social_item',
-    'subnav',
-    'subnav_item',
-    'switcher',
-    'switcher_item',
-    'table',
-    'table_item',
-]);
-/**
- * Is `childType` a valid DIRECT child of the layout root? Permissive for the
- * empty type and for unknown / fragment types.
- */
-export function isAllowedRootChild(childType) {
-    if (childType === '') {
-        return true;
-    }
-    if (ROOT_ALLOWED.includes(childType)) {
-        return true;
-    }
-    return !KNOWN_NON_SECTION_TYPES.has(childType);
-}
-/**
- * Is `childType` a valid child of `parentType`? Strict parents enforce
- * their allow-list; every other parent is permissive.
- */
-export function isAllowedChild(parentType, childType) {
-    const allowed = allowedChildrenOf(parentType);
-    if (allowed === null) {
-        return true;
-    }
-    return allowed.includes(childType);
-}
-/** Is `type` one of the STRICT structural parents (section / row)? */
-export function isStructuralParent(type) {
-    return Object.prototype.hasOwnProperty.call(STRICT_PARENTS, type);
-}
-/**
- * Is `childType` a type the STATIC grammar can positively reason about WITHOUT
- * the live YT element-registry? True for the closed grammar (`section` + every
- * KNOWN-non-section type); false for unknown / 3rd-party / `fragment` types
- * (which stay degrade-permissive). Mirror of the PHP
- * `LayoutHierarchyRules::isStaticallyDecidableChild`.
- */
-export function isStaticallyDecidableChild(childType) {
-    if (childType === '') {
-        return false;
-    }
-    if (ROOT_ALLOWED.includes(childType)) {
-        return true;
-    }
-    return KNOWN_NON_SECTION_TYPES.has(childType);
-}
-//# sourceMappingURL=layout-hierarchy-rules.js.map

package/dist/tools/elements/layout-hierarchy-rules.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout-hierarchy-rules.js","sourceRoot":"","sources":["../../../src/tools/elements/layout-hierarchy-rules.ts"],"names":[],"mappings":"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"}

package/dist/tools/elements/schema-validation.d.ts

@@ -1,218 +0,0 @@
-/**
- * Finding B3 — schema-driven write validation for element props.
- *
- * The static `COMMON_PROP_TYPOS` map + `RESERVED_BINDING_KEYS` set in
- * `./handlers-write.ts` only catch a small fixed set of known mistakes. An
- * unknown prop key that is NOT in those tables slips through, the PHP backend
- * silently drops it, and the element renders empty with no signal to the agent
- * (customer B3).
- *
- * This module adds a LIVE cross-check against the element-type's real schema:
- * the authoritative prop keys are `fields[].name` from
- * `GET /element-types/<type>/schema` — the same source the B1
- * `yootheme_builder_element_type_get_schema` tool surfaces (see
- * `../inspection.ts`). When the schema is KNOWN and a key is SURELY unknown,
- * the write is hard-rejected with a Levenshtein `did_you_mean` suggestion.
- *
- * Additive-before-breaking (the plugin is live 1.6.x): every uncertainty —
- * schema fetch failure, unknown schema shape, empty field list — falls THROUGH
- * to the prior behaviour. A schema fetch must NEVER crash the write.
- *
- * @license MIT
- */
-import type { RestClient } from '../../client.js';
-import { type ToolResult } from '../tool-builder.js';
-/**
- * MCP-side mirror of `Inspector::knownAcceptedButHiddenFields`
- * (`src/modules/builder-inspection/src/Inspector.php`). YT-Pro accepts these
- * props at runtime even though the UI-tab `fieldset` omits them. The PHP
- * `schema()` endpoint already post-merges them into `fields[]`, so a current
- * (1.6.x) plugin schema covers them. This mirror is DEFENSE-IN-DEPTH: against
- * an older plugin whose schema predates that merge, it keeps a genuinely
- * runtime-accepted prop from being false-positive hard-rejected. Keep in sync
- * with the PHP list (deliberately small + ground-truthed).
- */
-export declare const RUNTIME_ACCEPTED_HIDDEN_PROPS: Readonly<Record<string, readonly string[]>>;
-/**
- * Levenshtein edit distance — small pure function (keys are short). Index
- * access is guarded with `?? 0` to satisfy `noUncheckedIndexedAccess`; the
- * row is fully populated at every access so the fallback never fires.
- */
-export declare function levenshtein(a: string, b: string): number;
-/**
- * Closest real field name for `key`, or `undefined` when nothing is close
- * enough to suggest. Threshold (pinned in tests): `min(max(2, floor(0.4 ·
- * key.length)), key.length - 1)` — always tolerate 1–2 char typos and
- * proportionally more on longer keys, but a suggestion must be CLOSER than the
- * whole key length (M1 clamp), so a wholly-different word is never "suggested".
- */
-export declare function nearestFieldName(key: string, fields: readonly string[]): string | undefined;
-/**
- * PAGES_LIBRARY_MEDIA-27 — suggest real field names for an unknown key,
- * combining TWO signals so an obviously-intended key is never missed:
- *
- *   1. PREFIX / SUBSTRING match — a `title` key on a headline should suggest
- *      `title_element` / `title_style` / `title_color`, but char-Levenshtein to
- *      each of those is 6-8 (well over the typo threshold), so the pure-distance
- *      `nearestFieldName` returns nothing. When the unknown key (≥ 3 chars) is a
- *      prefix of — or a substring of — a real field, surface EVERY such field
- *      regardless of edit distance: these are the concrete keys the caller most
- *      likely meant.
- *   2. Levenshtein nearest — the general single/double-char typo case.
- *
- * Prefix matches lead (they are the strongest signal), then substring matches,
- * then the Levenshtein nearest if not already covered. De-duplicated, order
- * preserved. Returns `[]` when nothing is close.
- */
-export declare function suggestFieldNames(key: string, fields: readonly string[]): string[];
-/**
- * Ordering-red-border fix (2026-07-25) — the full per-field wire shape, as
- * opposed to `extractSchemaFieldNames`' bare name list. `enum`/`default` were
- * previously fetched by every caller (via `fields[].name` extraction) and then
- * DISCARDED — this is what `element_add`'s required-enum default-seeding and
- * explicit-invalid-enum-value hard-reject (`seedRequiredEnumDefaults` /
- * `validateEnumPropValues`, below) need to do their job.
- */
-export interface SchemaField {
-    readonly name: string;
-    readonly type?: string;
-    /** Normalised to `list<string>` server-side (`Inspector::extractEnum`); absent when the field has no dropdown/select options. */
-    readonly enum?: readonly string[];
-    /** `mixed` server-side; absent when the field declares no schema default. */
-    readonly default?: unknown;
-}
-/**
- * Pull the full `fields[]` list out of the element-type schema response.
- * Mirrors the envelope handling in `../inspection.ts`: the type schema nests
- * under `schema`, with a top-level fallback for older backends.
- *
- * @returns the field list (possibly empty), or `null` when the response
- *   carries no `fields` array at all (unknown schema shape → treat as unknown).
- */
-export declare function extractSchemaFields(data: unknown): SchemaField[] | null;
-/**
- * Pull `fields[].name` out of the element-type schema response. Thin
- * name-only projection of {@link extractSchemaFields} — kept as its own
- * export because every EXISTING caller/test only needs the name list.
- *
- * @returns the field-name list (possibly empty), or `null` when the response
- *   carries no `fields` array at all (unknown schema shape → treat as unknown).
- */
-export declare function extractSchemaFieldNames(data: unknown): string[] | null;
-/**
- * Best-effort fetch of an element-type's full field schema. ANY failure
- * (network, non-2xx, unknown shape) resolves to `null` so the caller falls
- * through to the prior behaviour — a schema fetch must never break the write.
- */
-export declare function fetchSchemaFields(client: RestClient, elementType: string): Promise<SchemaField[] | null>;
-/**
- * Best-effort fetch of an element-type's real prop keys. Name-only
- * projection of {@link fetchSchemaFields} — kept as its own export for
- * existing callers that only need the key list.
- */
-export declare function fetchSchemaFieldNames(client: RestClient, elementType: string): Promise<string[] | null>;
-/**
- * Validate `props` against the element-type's LIVE schema. Returns an
- * `errorResult` ONLY when the schema is surely known (non-empty field list) AND
- * at least one prop key is surely unknown; otherwise `null` (pass / fall
- * through). Reserved binding keys are skipped here — their dedicated guard runs
- * first and keeps priority.
- */
-export declare function validatePropsAgainstLiveSchema(opts: {
-    readonly client: RestClient;
-    readonly elementType: string;
-    readonly props: Record<string, unknown> | undefined;
-    readonly reservedKeys: ReadonlySet<string>;
-    /**
-     * Ordering-red-border fix (2026-07-25): reuse an ALREADY-fetched live
-     * schema (e.g. `element_add`'s default-seeding fetches it anyway) instead
-     * of a second network round-trip for the SAME element_type. `undefined`
-     * (the omitted default) preserves the original behaviour — this function
-     * fetches for itself. Passing `null` explicitly means "already fetched
-     * and it failed / was uncertain" and short-circuits to the same
-     * fall-through as a failed fetch, with no network call.
-     */
-    readonly fields?: readonly SchemaField[] | null;
-}): Promise<ToolResult | null>;
-/**
- * A field is "required" in the same sense the PHP-side `UiInvariantValidator`
- * uses for its `required_field_empty` violation: it is enum-constrained (a
- * non-empty `enum` list) and that list does NOT contain `''` — an optional
- * select always lists `''` as its "nothing selected" member.
- */
-export declare function isRequiredEnumField(field: SchemaField): boolean;
-/**
- * Seed every REQUIRED enum field (see {@link isRequiredEnumField}) that
- * declares a non-empty schema `default` and is ABSENT from `props` with that
- * default — mirroring what YOOtheme's own native element-creation
- * initialises. A field the caller already supplied a key for (any value,
- * including one later hard-rejected by {@link validateEnumPropValues}) is
- * never touched: the caller's own value ALWAYS wins, no coercion, ever. An
- * element type with no schema default for a field gets nothing invented for
- * it — the seed set only ever pulls from real schema data.
- *
- * Returns `props` UNCHANGED (same reference, possibly `undefined`) when
- * there is nothing to seed, so a no-op call never allocates a new object.
- */
-export declare function seedRequiredEnumDefaults(fields: readonly SchemaField[], props: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
-/**
- * Hard-reject a prop VALUE the caller explicitly supplied for a KNOWN
- * enum-constrained field when that value is not one of the field's declared
- * `enum` members. `validatePropsAgainstLiveSchema` only ever checks that a
- * prop KEY is known — this is the VALUE half, scoped to element_add's create
- * path only (see the section banner above for why).
- *
- * An empty value (`''` / `null` / `undefined`) is deliberately NOT judged
- * here — persisting an empty value on a required field is a DIFFERENT
- * violation (`required_field_empty`) the PHP write guard already owns; this
- * function only judges a genuinely non-empty value against enum membership.
- * A non-scalar value (a dynamic-binding shape) is skipped — it cannot be
- * safely compared against a string enum and is not this function's concern.
- *
- * Returns `null` (pass) whenever the field is unknown to the given `fields`
- * list or is not enum-constrained — this is a value check layered ON TOP of
- * the key check, never a whitelist on its own.
- */
-export declare function validateEnumPropValues(opts: {
-    readonly elementType: string;
-    readonly fields: readonly SchemaField[];
-    readonly props: Record<string, unknown> | undefined;
-    readonly reservedKeys: ReadonlySet<string>;
-}): ToolResult | null;
-/** A non-blocking note attached to a SUCCESSFUL write. */
-export interface HeaderTransparencyWarning {
-    readonly code: string;
-    readonly message: string;
-}
-export interface HeaderTransparencyGuardOutcome {
-    /** A hard reject (class A), or `null` when the write may proceed. */
-    readonly rejection: ToolResult | null;
-    /**
-     * The props to actually send — the SAME reference when nothing was seeded,
-     * so a no-op call never allocates and a byte-identical body is preserved.
-     */
-    readonly props: Record<string, unknown> | undefined;
-    readonly warnings: readonly HeaderTransparencyWarning[];
-}
-/**
- * Guard a props write against the transparent-header failure modes.
- *
- * Pure: takes the write's own payload (plus its merge/unset semantics) and
- * returns a rejection, the props to send, and any warnings. No I/O — it never
- * needs the element type either, because the three props are namespaced and
- * exist on `section` alone.
- */
-export declare function guardHeaderTransparencyWrite(opts: {
-    readonly props: Record<string, unknown> | undefined;
-    /** `true` = server-side deep merge; anything else = full replace (the default). */
-    readonly merge?: boolean;
-    readonly unset?: readonly string[];
-    readonly elementPath: string;
-}): HeaderTransparencyGuardOutcome;
-/**
- * Merge client-side warnings into a REST response body so a successful write
- * still carries them. A non-object body (or an empty warning list) is returned
- * untouched, so nothing that has no place to put them is reshaped.
- */
-export declare function withHeaderTransparencyWarnings(data: unknown, warnings: readonly HeaderTransparencyWarning[]): unknown;
-//# sourceMappingURL=schema-validation.d.ts.map

package/dist/tools/elements/schema-validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-validation.d.ts","sourceRoot":"","sources":["../../../src/tools/elements/schema-validation.ts"],"names":[],"mappings":"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"}