mewkit 1.15.0 → 1.16.0

package/dist/visual-plan/domain/feedback-schemas.d.ts

@@ -0,0 +1,160 @@
+/**
+ * `visual-feedback/v1` immutable batch schema + resolution-receipt schema.
+ *
+ * A feedback batch is written once and never mutated (red-team: immutability is
+ * the misapplication guard). It captures the reviewer's intent against an exact
+ * `baseRevision` + `baseHash`; the apply loop (Phase 6) refuses to apply a batch
+ * whose base no longer matches the artifact. The batch `id` is charset-locked so
+ * a consumer can validate it BEFORE any path join.
+ *
+ * The resolution receipt mirrors the batch, recording a per-operation outcome
+ * (`applied | rejected | unresolved`). Batches remain byte-immutable after
+ * resolution; the receipt is the mutable-outcome surface.
+ *
+ * `markup` operation points are position-absolute / unanchored (red-team L3):
+ * they do NOT track frames across layout regeneration — documented, not a bug.
+ */
+import { z } from "zod";
+export declare const FEEDBACK_OP_TYPES: readonly ["annotation", "copy-change", "field-change", "flow-change", "scope-change", "other"];
+export declare const FeedbackBatchSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"visual-feedback/v1">;
+    id: z.ZodString;
+    planId: z.ZodString;
+    baseRevision: z.ZodNumber;
+    baseHash: z.ZodString;
+    createdAt: z.ZodString;
+    operations: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["annotation", "copy-change", "field-change", "flow-change", "scope-change", "other"]>;
+        frameId: z.ZodOptional<z.ZodString>;
+        elementId: z.ZodOptional<z.ZodString>;
+        sourceRefId: z.ZodOptional<z.ZodString>;
+        visualPoint: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            y: number;
+            x: number;
+        }, {
+            y: number;
+            x: number;
+        }>>;
+        intent: z.ZodString;
+        comment: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        type: "annotation" | "other" | "copy-change" | "field-change" | "flow-change" | "scope-change";
+        intent: string;
+        context?: string | undefined;
+        frameId?: string | undefined;
+        elementId?: string | undefined;
+        sourceRefId?: string | undefined;
+        visualPoint?: {
+            y: number;
+            x: number;
+        } | undefined;
+        comment?: string | undefined;
+    }, {
+        type: "annotation" | "other" | "copy-change" | "field-change" | "flow-change" | "scope-change";
+        intent: string;
+        context?: string | undefined;
+        frameId?: string | undefined;
+        elementId?: string | undefined;
+        sourceRefId?: string | undefined;
+        visualPoint?: {
+            y: number;
+            x: number;
+        } | undefined;
+        comment?: string | undefined;
+    }>, "many">;
+    status: z.ZodDefault<z.ZodEnum<["open", "resolved"]>>;
+}, "strict", z.ZodTypeAny, {
+    status: "resolved" | "open";
+    schemaVersion: "visual-feedback/v1";
+    id: string;
+    planId: string;
+    baseRevision: number;
+    baseHash: string;
+    createdAt: string;
+    operations: {
+        type: "annotation" | "other" | "copy-change" | "field-change" | "flow-change" | "scope-change";
+        intent: string;
+        context?: string | undefined;
+        frameId?: string | undefined;
+        elementId?: string | undefined;
+        sourceRefId?: string | undefined;
+        visualPoint?: {
+            y: number;
+            x: number;
+        } | undefined;
+        comment?: string | undefined;
+    }[];
+}, {
+    schemaVersion: "visual-feedback/v1";
+    id: string;
+    planId: string;
+    baseRevision: number;
+    baseHash: string;
+    createdAt: string;
+    operations: {
+        type: "annotation" | "other" | "copy-change" | "field-change" | "flow-change" | "scope-change";
+        intent: string;
+        context?: string | undefined;
+        frameId?: string | undefined;
+        elementId?: string | undefined;
+        sourceRefId?: string | undefined;
+        visualPoint?: {
+            y: number;
+            x: number;
+        } | undefined;
+        comment?: string | undefined;
+    }[];
+    status?: "resolved" | "open" | undefined;
+}>;
+export type FeedbackBatch = z.infer<typeof FeedbackBatchSchema>;
+export declare const ResolutionReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"visual-feedback-receipt/v1">;
+    batchId: z.ZodString;
+    planId: z.ZodString;
+    baseRevision: z.ZodNumber;
+    resolvedAtRevision: z.ZodNumber;
+    resolvedAt: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        outcome: z.ZodEnum<["applied", "rejected", "unresolved"]>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        index: number;
+        outcome: "rejected" | "applied" | "unresolved";
+        notes?: string | undefined;
+    }, {
+        index: number;
+        outcome: "rejected" | "applied" | "unresolved";
+        notes?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    entries: {
+        index: number;
+        outcome: "rejected" | "applied" | "unresolved";
+        notes?: string | undefined;
+    }[];
+    schemaVersion: "visual-feedback-receipt/v1";
+    planId: string;
+    baseRevision: number;
+    batchId: string;
+    resolvedAtRevision: number;
+    resolvedAt: string;
+}, {
+    entries: {
+        index: number;
+        outcome: "rejected" | "applied" | "unresolved";
+        notes?: string | undefined;
+    }[];
+    schemaVersion: "visual-feedback-receipt/v1";
+    planId: string;
+    baseRevision: number;
+    batchId: string;
+    resolvedAtRevision: number;
+    resolvedAt: string;
+}>;
+export type ResolutionReceipt = z.infer<typeof ResolutionReceiptSchema>;
+//# sourceMappingURL=feedback-schemas.d.ts.map

package/dist/visual-plan/domain/feedback-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback-schemas.d.ts","sourceRoot":"","sources":["../../../src/visual-plan/domain/feedback-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,iBAAiB,gGAOpB,CAAC;AAeX,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWtB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAUhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU1B,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/visual-plan/domain/feedback-schemas.js

@@ -0,0 +1,71 @@
+/**
+ * `visual-feedback/v1` immutable batch schema + resolution-receipt schema.
+ *
+ * A feedback batch is written once and never mutated (red-team: immutability is
+ * the misapplication guard). It captures the reviewer's intent against an exact
+ * `baseRevision` + `baseHash`; the apply loop (Phase 6) refuses to apply a batch
+ * whose base no longer matches the artifact. The batch `id` is charset-locked so
+ * a consumer can validate it BEFORE any path join.
+ *
+ * The resolution receipt mirrors the batch, recording a per-operation outcome
+ * (`applied | rejected | unresolved`). Batches remain byte-immutable after
+ * resolution; the receipt is the mutable-outcome surface.
+ *
+ * `markup` operation points are position-absolute / unanchored (red-team L3):
+ * they do NOT track frames across layout regeneration — documented, not a bug.
+ */
+import { z } from "zod";
+import { ENTITY_ID_RE, FEEDBACK_BATCH_ID_RE } from "./ids.js";
+const EntityId = z.string().regex(ENTITY_ID_RE);
+const BatchId = z.string().regex(FEEDBACK_BATCH_ID_RE, "invalid feedback batch id (path-injection guard)");
+export const FEEDBACK_OP_TYPES = [
+    "annotation",
+    "copy-change",
+    "field-change",
+    "flow-change",
+    "scope-change",
+    "other",
+];
+const FeedbackOperationSchema = z
+    .object({
+    type: z.enum(FEEDBACK_OP_TYPES),
+    frameId: EntityId.optional(),
+    elementId: z.string().optional(),
+    sourceRefId: EntityId.optional(),
+    visualPoint: z.object({ x: z.number(), y: z.number() }).strict().optional(),
+    intent: z.string().min(1),
+    comment: z.string().optional(),
+    context: z.string().optional(),
+})
+    .strict();
+export const FeedbackBatchSchema = z
+    .object({
+    schemaVersion: z.literal("visual-feedback/v1"),
+    id: BatchId,
+    planId: EntityId,
+    baseRevision: z.number().int().nonnegative(),
+    baseHash: z.string().min(1),
+    createdAt: z.string().min(1),
+    operations: z.array(FeedbackOperationSchema).min(1).max(500),
+    status: z.enum(["open", "resolved"]).default("open"),
+})
+    .strict();
+const ResolutionEntrySchema = z
+    .object({
+    index: z.number().int().nonnegative(),
+    outcome: z.enum(["applied", "rejected", "unresolved"]),
+    notes: z.string().optional(),
+})
+    .strict();
+export const ResolutionReceiptSchema = z
+    .object({
+    schemaVersion: z.literal("visual-feedback-receipt/v1"),
+    batchId: BatchId,
+    planId: EntityId,
+    baseRevision: z.number().int().nonnegative(),
+    resolvedAtRevision: z.number().int().nonnegative(),
+    resolvedAt: z.string().min(1),
+    entries: z.array(ResolutionEntrySchema),
+})
+    .strict();
+//# sourceMappingURL=feedback-schemas.js.map

package/dist/visual-plan/domain/feedback-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback-schemas.js","sourceRoot":"","sources":["../../../src/visual-plan/domain/feedback-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAE9D,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;AAChD,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,oBAAoB,EAAE,kDAAkD,CAAC,CAAC;AAE3G,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAChC,YAAY;IACZ,aAAa;IACb,cAAc;IACd,aAAa;IACb,cAAc;IACd,OAAO;CACE,CAAC;AAEX,MAAM,uBAAuB,GAAG,CAAC;KAC/B,MAAM,CAAC;IACP,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC;IAC/B,OAAO,EAAE,QAAQ,CAAC,QAAQ,EAAE;IAC5B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,WAAW,EAAE,QAAQ,CAAC,QAAQ,EAAE;IAChC,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3E,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC;KACD,MAAM,EAAE,CAAC;AAEX,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC;KAClC,MAAM,CAAC;IACP,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IAC9C,EAAE,EAAE,OAAO;IACX,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC5C,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5B,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAC5D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;CACpD,CAAC;KACD,MAAM,EAAE,CAAC;AAIX,MAAM,qBAAqB,GAAG,CAAC;KAC7B,MAAM,CAAC;IACP,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACrC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC;IACtD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC5B,CAAC;KACD,MAAM,EAAE,CAAC;AAEX,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC;KACtC,MAAM,CAAC;IACP,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,4BAA4B,CAAC;IACtD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC5C,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAClD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC;CACvC,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/visual-plan/domain/ids.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared identifier patterns for the visual-plan contracts.
+ *
+ * Feedback batch ids are the security-sensitive one: a consumer validates the
+ * id against `FEEDBACK_BATCH_ID_RE` BEFORE any path join (red-team M8), so the
+ * charset is deliberately narrow — no dots, slashes, or path separators can
+ * appear in a batch filename.
+ */
+/** Generic artifact-internal id: lowercase/uppercase alnum + hyphen/underscore. */
+export declare const ENTITY_ID_RE: RegExp;
+/**
+ * Strict feedback-batch id: `feedback-<digits>-<slug>`. The fixed charset makes
+ * the id safe to interpolate into a filename without traversal risk. Validated
+ * before any path join.
+ */
+export declare const FEEDBACK_BATCH_ID_RE: RegExp;
+/** True when `id` is a structurally valid artifact-internal id. */
+export declare function isValidEntityId(id: string): boolean;
+/** True when `id` is a structurally valid feedback-batch id (path-injection safe). */
+export declare function isValidFeedbackBatchId(id: string): boolean;
+//# sourceMappingURL=ids.d.ts.map

package/dist/visual-plan/domain/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../src/visual-plan/domain/ids.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,mFAAmF;AACnF,eAAO,MAAM,YAAY,QAAsC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAgD,CAAC;AAElF,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE1D"}

package/dist/visual-plan/domain/ids.js

@@ -0,0 +1,25 @@
+/**
+ * Shared identifier patterns for the visual-plan contracts.
+ *
+ * Feedback batch ids are the security-sensitive one: a consumer validates the
+ * id against `FEEDBACK_BATCH_ID_RE` BEFORE any path join (red-team M8), so the
+ * charset is deliberately narrow — no dots, slashes, or path separators can
+ * appear in a batch filename.
+ */
+/** Generic artifact-internal id: lowercase/uppercase alnum + hyphen/underscore. */
+export const ENTITY_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+/**
+ * Strict feedback-batch id: `feedback-<digits>-<slug>`. The fixed charset makes
+ * the id safe to interpolate into a filename without traversal risk. Validated
+ * before any path join.
+ */
+export const FEEDBACK_BATCH_ID_RE = /^feedback-\d{8,}-[a-z0-9]([a-z0-9-]{0,63})$/;
+/** True when `id` is a structurally valid artifact-internal id. */
+export function isValidEntityId(id) {
+    return ENTITY_ID_RE.test(id);
+}
+/** True when `id` is a structurally valid feedback-batch id (path-injection safe). */
+export function isValidFeedbackBatchId(id) {
+    return FEEDBACK_BATCH_ID_RE.test(id);
+}
+//# sourceMappingURL=ids.js.map

package/dist/visual-plan/domain/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../../src/visual-plan/domain/ids.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,YAAY,GAAG,mCAAmC,CAAC;AAEhE;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,6CAA6C,CAAC;AAElF,mEAAmE;AACnE,MAAM,UAAU,eAAe,CAAC,EAAU;IACzC,OAAO,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC9B,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,sBAAsB,CAAC,EAAU;IAChD,OAAO,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACtC,CAAC"}

package/dist/visual-plan/domain/patches.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Typed VISUAL-ONLY patch operations (Phase 5).
+ *
+ * These are the only mutations the studio may apply directly to the artifact —
+ * lane/order moves, annotation add/edit/remove, connector-label edits, and
+ * schema-backed wireframe TEXT-field edits. Raw HTML/CSS editing, freeform
+ * resize, and Markdown edits are NOT patch ops (semantic changes go through the
+ * feedback→agent loop). Every accepted patch bumps `revision` and clears
+ * approval; the application layer re-validates the mutated plan before writing.
+ *
+ * A wireframe field is targeted by a `wf-field-<id>` CLASS in the wireframe HTML
+ * (class is in the sanitizer allowlist, so no allowlist change is needed) — only
+ * that element's TEXT content is replaced, then the whole wireframe re-sanitized.
+ */
+import { z } from "zod";
+export declare const PatchOpSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"move-frame-lane">;
+    frameId: z.ZodString;
+    laneId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "move-frame-lane";
+    laneId: string;
+    frameId: string;
+}, {
+    type: "move-frame-lane";
+    laneId: string;
+    frameId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"reorder-frame">;
+    frameId: z.ZodString;
+    order: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    type: "reorder-frame";
+    order: number;
+    frameId: string;
+}, {
+    type: "reorder-frame";
+    order: number;
+    frameId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"update-annotation">;
+    annotationId: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    placement: z.ZodOptional<z.ZodEnum<["top", "right", "bottom", "left"]>>;
+    points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        y: number;
+        x: number;
+    }, {
+        y: number;
+        x: number;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    type: "update-annotation";
+    annotationId: string;
+    text?: string | undefined;
+    placement?: "top" | "right" | "bottom" | "left" | undefined;
+    points?: {
+        y: number;
+        x: number;
+    }[] | undefined;
+}, {
+    type: "update-annotation";
+    annotationId: string;
+    text?: string | undefined;
+    placement?: "top" | "right" | "bottom" | "left" | undefined;
+    points?: {
+        y: number;
+        x: number;
+    }[] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"append-annotation">;
+    annotation: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<["note", "markup"]>;
+        text: z.ZodString;
+        targetId: z.ZodOptional<z.ZodString>;
+        placement: z.ZodOptional<z.ZodEnum<["top", "right", "bottom", "left"]>>;
+        points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            y: number;
+            x: number;
+        }, {
+            y: number;
+            x: number;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        kind: "note" | "markup";
+        text: string;
+        targetId?: string | undefined;
+        placement?: "top" | "right" | "bottom" | "left" | undefined;
+        points?: {
+            y: number;
+            x: number;
+        }[] | undefined;
+    }, {
+        id: string;
+        kind: "note" | "markup";
+        text: string;
+        targetId?: string | undefined;
+        placement?: "top" | "right" | "bottom" | "left" | undefined;
+        points?: {
+            y: number;
+            x: number;
+        }[] | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    type: "append-annotation";
+    annotation: {
+        id: string;
+        kind: "note" | "markup";
+        text: string;
+        targetId?: string | undefined;
+        placement?: "top" | "right" | "bottom" | "left" | undefined;
+        points?: {
+            y: number;
+            x: number;
+        }[] | undefined;
+    };
+}, {
+    type: "append-annotation";
+    annotation: {
+        id: string;
+        kind: "note" | "markup";
+        text: string;
+        targetId?: string | undefined;
+        placement?: "top" | "right" | "bottom" | "left" | undefined;
+        points?: {
+            y: number;
+            x: number;
+        }[] | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"remove-annotation">;
+    annotationId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "remove-annotation";
+    annotationId: string;
+}, {
+    type: "remove-annotation";
+    annotationId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"update-connector-label">;
+    connectorId: z.ZodString;
+    label: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "update-connector-label";
+    label: string;
+    connectorId: string;
+}, {
+    type: "update-connector-label";
+    label: string;
+    connectorId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"update-wireframe-field">;
+    frameId: z.ZodString;
+    fieldId: z.ZodString;
+    text: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "update-wireframe-field";
+    text: string;
+    frameId: string;
+    fieldId: string;
+}, {
+    type: "update-wireframe-field";
+    text: string;
+    frameId: string;
+    fieldId: string;
+}>]>;
+export type PatchOp = z.infer<typeof PatchOpSchema>;
+//# sourceMappingURL=patches.d.ts.map

package/dist/visual-plan/domain/patches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patches.d.ts","sourceRoot":"","sources":["../../../src/visual-plan/domain/patches.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/visual-plan/domain/patches.js

@@ -0,0 +1,41 @@
+/**
+ * Typed VISUAL-ONLY patch operations (Phase 5).
+ *
+ * These are the only mutations the studio may apply directly to the artifact —
+ * lane/order moves, annotation add/edit/remove, connector-label edits, and
+ * schema-backed wireframe TEXT-field edits. Raw HTML/CSS editing, freeform
+ * resize, and Markdown edits are NOT patch ops (semantic changes go through the
+ * feedback→agent loop). Every accepted patch bumps `revision` and clears
+ * approval; the application layer re-validates the mutated plan before writing.
+ *
+ * A wireframe field is targeted by a `wf-field-<id>` CLASS in the wireframe HTML
+ * (class is in the sanitizer allowlist, so no allowlist change is needed) — only
+ * that element's TEXT content is replaced, then the whole wireframe re-sanitized.
+ */
+import { z } from "zod";
+import { ENTITY_ID_RE } from "./ids.js";
+import { AnnotationSchema } from "./schemas.js";
+const EntityId = z.string().regex(ENTITY_ID_RE);
+const Placement = z.enum(["top", "right", "bottom", "left"]);
+const Points = z.array(z.object({ x: z.number(), y: z.number() }).strict());
+const MoveFrameLane = z.object({ type: z.literal("move-frame-lane"), frameId: EntityId, laneId: EntityId }).strict();
+const ReorderFrame = z.object({ type: z.literal("reorder-frame"), frameId: EntityId, order: z.number().int() }).strict();
+const UpdateAnnotation = z
+    .object({ type: z.literal("update-annotation"), annotationId: EntityId, text: z.string().min(1).optional(), placement: Placement.optional(), points: Points.optional() })
+    .strict();
+const AppendAnnotation = z.object({ type: z.literal("append-annotation"), annotation: AnnotationSchema }).strict();
+const RemoveAnnotation = z.object({ type: z.literal("remove-annotation"), annotationId: EntityId }).strict();
+const UpdateConnectorLabel = z.object({ type: z.literal("update-connector-label"), connectorId: EntityId, label: z.string() }).strict();
+const UpdateWireframeField = z
+    .object({ type: z.literal("update-wireframe-field"), frameId: EntityId, fieldId: EntityId, text: z.string() })
+    .strict();
+export const PatchOpSchema = z.discriminatedUnion("type", [
+    MoveFrameLane,
+    ReorderFrame,
+    UpdateAnnotation,
+    AppendAnnotation,
+    RemoveAnnotation,
+    UpdateConnectorLabel,
+    UpdateWireframeField,
+]);
+//# sourceMappingURL=patches.js.map

package/dist/visual-plan/domain/patches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patches.js","sourceRoot":"","sources":["../../../src/visual-plan/domain/patches.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;AAChD,MAAM,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;AAC7D,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;AAE5E,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AACrH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AACzH,MAAM,gBAAgB,GAAG,CAAC;KACxB,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,SAAS,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;KACxK,MAAM,EAAE,CAAC;AACX,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AACnH,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AAC7G,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,wBAAwB,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AACxI,MAAM,oBAAoB,GAAG,CAAC;KAC5B,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,wBAAwB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;KAC7G,MAAM,EAAE,CAAC;AAEX,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IACzD,aAAa;IACb,YAAY;IACZ,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB;IAChB,oBAAoB;IACpB,oBAAoB;CACpB,CAAC,CAAC"}

package/dist/visual-plan/domain/sanitizer-config.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared wireframe-sanitizer allowlist config.
+ *
+ * This module is the SINGLE source of truth for the sanitizer boundary and is
+ * imported by BOTH sides (red-team H2): the Node save-time sanitizer here in
+ * Phase 1 (jsdom-backed DOMPurify) and the browser render-time sanitizer in
+ * Phase 4 (native-DOM DOMPurify). Two parsers over ONE allowlist is the only
+ * way to keep the reject-at-save and re-sanitize-at-render decisions identical.
+ *
+ * It is pure data — no DOM, no jsdom, no dompurify import — so both environments
+ * can consume it without pulling in the other's engine.
+ *
+ * Reject semantics (not repair): the caller sanitizes with this config, then
+ * diffs the sanitized output against the DOM-normalized input; ANY delta is a
+ * rejection with a JSON path. This config's job is only to define what "safe"
+ * means; the diff enforces reject-not-repair.
+ */
+/**
+ * Semantic wireframe tag vocabulary. Anything outside this list is stripped by
+ * DOMPurify, which the reject-diff then turns into a hard error. Interactive
+ * form controls (`input`, `textarea`, `select`, `form`) are intentionally
+ * absent — wireframes represent them as `.wf-*`-classed structural elements,
+ * never live controls.
+ */
+export declare const WIREFRAME_ALLOWED_TAGS: readonly string[];
+/**
+ * Allowed attributes. `class` carries the `.wf-*` vocabulary; `href` is allowed
+ * but scheme-restricted by `WIREFRAME_ALLOWED_URI_REGEXP`. `style` is NOT
+ * allowed (inline CSS is how fixed-position / z-index / font-face attacks
+ * arrive), so any `style=` attribute is stripped and the diff rejects it.
+ */
+export declare const WIREFRAME_ALLOWED_ATTR: readonly string[];
+/**
+ * URL scheme allowlist for `href`. Permits http(s), mailto, in-page anchors,
+ * and site-relative paths (a single leading `/`). Everything else —
+ * `javascript:`, `data:`, `vbscript:`, tab/entity-obfuscated schemes, AND
+ * protocol-relative `//host` (which resolves to an external origin) — is
+ * rejected by DOMPurify and the diff.
+ */
+export declare const WIREFRAME_ALLOWED_URI_REGEXP: RegExp;
+/**
+ * The DOMPurify config object, identical on both sides.
+ *
+ * NOTE: `USE_PROFILES` is deliberately NOT set — DOMPurify IGNORES
+ * `ALLOWED_TAGS`/`ALLOWED_ATTR` whenever a profile is present, and the built-in
+ * html profile permits form controls. The explicit `ALLOWED_TAGS` allowlist is
+ * strictly stronger: anything outside it (form controls, SVG, MathML, script)
+ * is stripped, which the reject-diff turns into a hard error. Data/ARIA attrs
+ * are off; `style` is force-forbidden even though it is already off-allowlist.
+ */
+export declare const WIREFRAME_SANITIZE_CONFIG: {
+    ALLOWED_TAGS: string[];
+    ALLOWED_ATTR: string[];
+    ALLOW_DATA_ATTR: boolean;
+    ALLOW_ARIA_ATTR: boolean;
+    FORBID_ATTR: string[];
+    FORBID_TAGS: string[];
+    ALLOWED_URI_REGEXP: RegExp;
+    WHOLE_DOCUMENT: boolean;
+};
+//# sourceMappingURL=sanitizer-config.d.ts.map

package/dist/visual-plan/domain/sanitizer-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizer-config.d.ts","sourceRoot":"","sources":["../../../src/visual-plan/domain/sanitizer-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EASnD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAAuC,CAAC;AAE5F;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,QAAwC,CAAC;AAElF;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;CASrC,CAAC"}

package/dist/visual-plan/domain/sanitizer-config.js

@@ -0,0 +1,70 @@
+/**
+ * Shared wireframe-sanitizer allowlist config.
+ *
+ * This module is the SINGLE source of truth for the sanitizer boundary and is
+ * imported by BOTH sides (red-team H2): the Node save-time sanitizer here in
+ * Phase 1 (jsdom-backed DOMPurify) and the browser render-time sanitizer in
+ * Phase 4 (native-DOM DOMPurify). Two parsers over ONE allowlist is the only
+ * way to keep the reject-at-save and re-sanitize-at-render decisions identical.
+ *
+ * It is pure data — no DOM, no jsdom, no dompurify import — so both environments
+ * can consume it without pulling in the other's engine.
+ *
+ * Reject semantics (not repair): the caller sanitizes with this config, then
+ * diffs the sanitized output against the DOM-normalized input; ANY delta is a
+ * rejection with a JSON path. This config's job is only to define what "safe"
+ * means; the diff enforces reject-not-repair.
+ */
+/**
+ * Semantic wireframe tag vocabulary. Anything outside this list is stripped by
+ * DOMPurify, which the reject-diff then turns into a hard error. Interactive
+ * form controls (`input`, `textarea`, `select`, `form`) are intentionally
+ * absent — wireframes represent them as `.wf-*`-classed structural elements,
+ * never live controls.
+ */
+export const WIREFRAME_ALLOWED_TAGS = [
+    "section", "header", "footer", "main", "nav", "aside", "article",
+    "div", "span", "p",
+    "h1", "h2", "h3", "h4", "h5", "h6",
+    "ul", "ol", "li", "dl", "dt", "dd",
+    "a", "strong", "em", "small", "b", "i", "u", "code", "pre", "blockquote",
+    "figure", "figcaption", "hr", "br",
+    "table", "thead", "tbody", "tfoot", "tr", "th", "td", "caption",
+    "label",
+];
+/**
+ * Allowed attributes. `class` carries the `.wf-*` vocabulary; `href` is allowed
+ * but scheme-restricted by `WIREFRAME_ALLOWED_URI_REGEXP`. `style` is NOT
+ * allowed (inline CSS is how fixed-position / z-index / font-face attacks
+ * arrive), so any `style=` attribute is stripped and the diff rejects it.
+ */
+export const WIREFRAME_ALLOWED_ATTR = ["class", "href", "title", "role"];
+/**
+ * URL scheme allowlist for `href`. Permits http(s), mailto, in-page anchors,
+ * and site-relative paths (a single leading `/`). Everything else —
+ * `javascript:`, `data:`, `vbscript:`, tab/entity-obfuscated schemes, AND
+ * protocol-relative `//host` (which resolves to an external origin) — is
+ * rejected by DOMPurify and the diff.
+ */
+export const WIREFRAME_ALLOWED_URI_REGEXP = /^(?:(?:https?|mailto):|#|\/(?!\/))/i;
+/**
+ * The DOMPurify config object, identical on both sides.
+ *
+ * NOTE: `USE_PROFILES` is deliberately NOT set — DOMPurify IGNORES
+ * `ALLOWED_TAGS`/`ALLOWED_ATTR` whenever a profile is present, and the built-in
+ * html profile permits form controls. The explicit `ALLOWED_TAGS` allowlist is
+ * strictly stronger: anything outside it (form controls, SVG, MathML, script)
+ * is stripped, which the reject-diff turns into a hard error. Data/ARIA attrs
+ * are off; `style` is force-forbidden even though it is already off-allowlist.
+ */
+export const WIREFRAME_SANITIZE_CONFIG = {
+    ALLOWED_TAGS: [...WIREFRAME_ALLOWED_TAGS],
+    ALLOWED_ATTR: [...WIREFRAME_ALLOWED_ATTR],
+    ALLOW_DATA_ATTR: false,
+    ALLOW_ARIA_ATTR: false,
+    FORBID_ATTR: ["style"],
+    FORBID_TAGS: ["style", "script", "iframe", "object", "embed", "form", "svg", "math"],
+    ALLOWED_URI_REGEXP: WIREFRAME_ALLOWED_URI_REGEXP,
+    WHOLE_DOCUMENT: false,
+};
+//# sourceMappingURL=sanitizer-config.js.map

package/dist/visual-plan/domain/sanitizer-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizer-config.js","sourceRoot":"","sources":["../../../src/visual-plan/domain/sanitizer-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAsB;IACxD,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS;IAChE,KAAK,EAAE,MAAM,EAAE,GAAG;IAClB,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;IAClC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;IAClC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY;IACxE,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI;IAClC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS;IAC/D,OAAO;CACP,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAE5F;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,qCAAqC,CAAC;AAElF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACxC,YAAY,EAAE,CAAC,GAAG,sBAAsB,CAAC;IACzC,YAAY,EAAE,CAAC,GAAG,sBAAsB,CAAC;IACzC,eAAe,EAAE,KAAK;IACtB,eAAe,EAAE,KAAK;IACtB,WAAW,EAAE,CAAC,OAAO,CAAC;IACtB,WAAW,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC;IACpF,kBAAkB,EAAE,4BAA4B;IAChD,cAAc,EAAE,KAAK;CACrB,CAAC"}