@inf-monkeys-tech/monkeys 1.0.72 → 1.1.1

package/lib/contracts/render.js

@@ -1,81 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewProviderDescriptorSchema = exports.ApplicationHandoffSchema = exports.ApplicationHandoffEndpointSchema = exports.OverlayNodeSchema = exports.OverlayZIndexLaneSchema = exports.RenderTreeSchema = exports.RenderNodeSchema = exports.RenderResponsiveRuleSchema = exports.RenderLayoutSchema = exports.RenderLifecycleSchema = exports.RenderActivationSchema = exports.RenderScrollSchema = exports.RenderSurfaceSchema = exports.RenderNodeKindSchema = exports.RenderNodeStateSchema = exports.ProductContextSchema = void 0;
+exports.ViewProviderDescriptorSchema = exports.ApplicationHandoffSchema = exports.ApplicationHandoffEndpointSchema = exports.OverlayNodeSchema = exports.OverlayZIndexLaneSchema = exports.RenderTreeSchema = exports.RenderNodeSchema = exports.RenderStyleSchema = exports.RenderStyleValueSchema = exports.RenderResponsiveRuleSchema = exports.RenderLayoutSchema = exports.RenderLifecycleSchema = exports.RenderActivationSchema = exports.RenderScrollSchema = exports.RenderSurfaceSchema = exports.RenderNodeKindSchema = exports.RenderNodeStateSchema = exports.ProductContextSchema = void 0;
+const page_expression_1 = require("./page-expression");
 const zod_1 = require("zod");
 const common_1 = require("./common");
-exports.ProductContextSchema = zod_1.z.enum(['studio', 'kernel']);
+exports.ProductContextSchema = zod_1.z.enum(["studio", "kernel"]);
 exports.RenderNodeStateSchema = zod_1.z.enum([
-    'idle',
-    'loading',
-    'empty',
-    'error',
-    'success',
-    'disabled',
-    'selected',
+    "idle",
+    "loading",
+    "empty",
+    "error",
+    "success",
+    "disabled",
+    "selected",
 ]);
 exports.RenderNodeKindSchema = zod_1.z.enum([
-    'shell',
-    'page',
-    'navigation',
-    'view',
-    'record',
-    'control',
-    'detail',
-    'action',
-    'overlay',
-    'professional-provider',
+    "shell",
+    "page",
+    "navigation",
+    "view",
+    "record",
+    "control",
+    "detail",
+    "action",
+    "overlay",
+    "professional-provider",
 ]);
 exports.RenderSurfaceSchema = zod_1.z
     .object({
-    frameOwner: zod_1.z.enum(['host', 'provider', 'none']),
+    frameOwner: zod_1.z.enum(["host", "provider", "none"]),
     tone: common_1.ContractIdentifierSchema.optional(),
-    density: zod_1.z.enum(['compact', 'default', 'comfortable']),
+    density: zod_1.z.enum(["compact", "default", "comfortable"]),
 })
     .strict();
 exports.RenderScrollSchema = zod_1.z
     .object({
-    owner: zod_1.z.enum(['page', 'surface', 'provider']),
-    axis: zod_1.z.enum(['x', 'y', 'both', 'none']),
+    owner: zod_1.z.enum(["page", "surface", "provider"]),
+    axis: zod_1.z.enum(["x", "y", "both", "none"]),
     restoreKey: common_1.ContractIdentifierSchema.optional(),
     virtualizationBoundary: zod_1.z.boolean(),
 })
     .strict()
     .superRefine((scroll, context) => {
-    if (scroll.owner === 'provider' && scroll.restoreKey) {
+    if (scroll.owner === "provider" && scroll.restoreKey) {
         context.addIssue({
-            code: 'custom',
-            path: ['restoreKey'],
-            message: 'Provider-owned scroll state cannot declare a host restoreKey.',
+            code: "custom",
+            path: ["restoreKey"],
+            message: "Provider-owned scroll state cannot declare a host restoreKey.",
         });
     }
-    if (scroll.virtualizationBoundary && scroll.owner !== 'provider') {
+    if (scroll.virtualizationBoundary && scroll.owner !== "provider") {
         context.addIssue({
-            code: 'custom',
-            path: ['owner'],
-            message: 'A virtualization boundary must keep scroll ownership in the provider.',
+            code: "custom",
+            path: ["owner"],
+            message: "A virtualization boundary must keep scroll ownership in the provider.",
         });
     }
 });
 exports.RenderActivationSchema = zod_1.z
     .object({
     activationId: common_1.ContractIdentifierSchema,
-    mode: zod_1.z.enum(['navigate', 'select', 'drawer', 'modal', 'fullscreen', 'inline']),
-    targetPath: zod_1.z.string().trim().regex(/^\/(?!\/)/, 'Expected an application-relative path.').optional(),
-    history: zod_1.z.enum(['push', 'replace']).optional(),
+    mode: zod_1.z.enum([
+        "navigate",
+        "select",
+        "drawer",
+        "modal",
+        "fullscreen",
+        "inline",
+    ]),
+    targetPath: zod_1.z
+        .string()
+        .trim()
+        .regex(/^\/(?!\/)/, "Expected an application-relative path.")
+        .optional(),
+    history: zod_1.z.enum(["push", "replace"]).optional(),
 })
     .strict()
     .superRefine((activation, context) => {
-    if (activation.mode === 'navigate' && !activation.targetPath) {
-        context.addIssue({ code: 'custom', path: ['targetPath'], message: 'Navigate activation requires an application-relative targetPath.' });
+    if (activation.mode === "navigate" && !activation.targetPath) {
+        context.addIssue({
+            code: "custom",
+            path: ["targetPath"],
+            message: "Navigate activation requires an application-relative targetPath.",
+        });
     }
-    if (activation.mode !== 'navigate' && activation.targetPath) {
-        context.addIssue({ code: 'custom', path: ['targetPath'], message: 'Only navigate activation may declare targetPath.' });
+    if (activation.mode !== "navigate" && activation.targetPath) {
+        context.addIssue({
+            code: "custom",
+            path: ["targetPath"],
+            message: "Only navigate activation may declare targetPath.",
+        });
     }
 });
 exports.RenderLifecycleSchema = zod_1.z
     .object({
-    mountPolicy: zod_1.z.enum(['always', 'when-visible', 'when-active']),
-    queryPolicy: zod_1.z.enum(['always', 'when-visible', 'when-active', 'manual']),
+    mountPolicy: zod_1.z.enum(["always", "when-visible", "when-active"]),
+    queryPolicy: zod_1.z.enum(["always", "when-visible", "when-active", "manual"]),
     retainOnDeactivate: zod_1.z.boolean(),
     deepLink: zod_1.z.boolean(),
     focusReturn: zod_1.z.boolean(),
@@ -83,23 +103,35 @@ exports.RenderLifecycleSchema = zod_1.z
     .strict();
 exports.RenderLayoutSchema = zod_1.z
     .object({
-    mode: zod_1.z.enum(['contents', 'block', 'flex', 'grid', 'absolute']),
-    direction: zod_1.z.enum(['row', 'column']).optional(),
+    mode: zod_1.z.enum(["contents", "block", "flex", "grid", "absolute"]),
+    direction: zod_1.z.enum(["row", "column"]).optional(),
     columns: zod_1.z.number().int().positive().optional(),
-    align: zod_1.z.enum(['start', 'center', 'end', 'stretch']).optional(),
-    justify: zod_1.z.enum(['start', 'center', 'end', 'between', 'around']).optional(),
+    align: zod_1.z.enum(["start", "center", "end", "stretch"]).optional(),
+    justify: zod_1.z.enum(["start", "center", "end", "between", "around"]).optional(),
     gapTokenRef: common_1.EntityRefSchema.optional(),
 })
     .strict()
     .superRefine((layout, context) => {
-    if (layout.direction && layout.mode !== 'flex') {
-        context.addIssue({ code: 'custom', path: ['direction'], message: 'direction is only valid for flex layout.' });
+    if (layout.direction && layout.mode !== "flex") {
+        context.addIssue({
+            code: "custom",
+            path: ["direction"],
+            message: "direction is only valid for flex layout.",
+        });
     }
-    if (layout.columns && layout.mode !== 'grid') {
-        context.addIssue({ code: 'custom', path: ['columns'], message: 'columns is only valid for grid layout.' });
+    if (layout.columns && layout.mode !== "grid") {
+        context.addIssue({
+            code: "custom",
+            path: ["columns"],
+            message: "columns is only valid for grid layout.",
+        });
     }
-    if (layout.gapTokenRef && layout.gapTokenRef.kind !== 'design-token') {
-        context.addIssue({ code: 'custom', path: ['gapTokenRef', 'kind'], message: 'gapTokenRef must reference design-token.' });
+    if (layout.gapTokenRef && layout.gapTokenRef.kind !== "design-token") {
+        context.addIssue({
+            code: "custom",
+            path: ["gapTokenRef", "kind"],
+            message: "gapTokenRef must reference design-token.",
+        });
     }
 });
 exports.RenderResponsiveRuleSchema = zod_1.z
@@ -111,20 +143,143 @@ exports.RenderResponsiveRuleSchema = zod_1.z
     .strict()
     .superRefine((rule, context) => {
     if (rule.minWidthPx === undefined && rule.maxWidthPx === undefined) {
-        context.addIssue({ code: 'custom', path: [], message: 'Responsive rule must declare minWidthPx or maxWidthPx.' });
+        context.addIssue({
+            code: "custom",
+            path: [],
+            message: "Responsive rule must declare minWidthPx or maxWidthPx.",
+        });
     }
-    if (rule.minWidthPx !== undefined && rule.maxWidthPx !== undefined && rule.minWidthPx > rule.maxWidthPx) {
-        context.addIssue({ code: 'custom', path: ['maxWidthPx'], message: 'maxWidthPx must be greater than or equal to minWidthPx.' });
+    if (rule.minWidthPx !== undefined &&
+        rule.maxWidthPx !== undefined &&
+        rule.minWidthPx > rule.maxWidthPx) {
+        context.addIssue({
+            code: "custom",
+            path: ["maxWidthPx"],
+            message: "maxWidthPx must be greater than or equal to minWidthPx.",
+        });
     }
 });
+exports.RenderStyleValueSchema = zod_1.z.union([
+    zod_1.z.number().finite(),
+    zod_1.z
+        .string()
+        .trim()
+        .min(1)
+        .max(256)
+        .superRefine((value, context) => {
+        if (/[;{}]/.test(value) ||
+            /(?:url|expression|javascript|var)\s*\(/i.test(value)) {
+            context.addIssue({
+                code: "custom",
+                message: "Render style values must be bounded CSS values or $ Design Token references.",
+            });
+        }
+    }),
+]);
+exports.RenderStyleSchema = zod_1.z
+    .object({
+    width: exports.RenderStyleValueSchema.optional(),
+    height: exports.RenderStyleValueSchema.optional(),
+    minWidth: exports.RenderStyleValueSchema.optional(),
+    maxWidth: exports.RenderStyleValueSchema.optional(),
+    minHeight: exports.RenderStyleValueSchema.optional(),
+    maxHeight: exports.RenderStyleValueSchema.optional(),
+    padding: exports.RenderStyleValueSchema.optional(),
+    paddingBlock: exports.RenderStyleValueSchema.optional(),
+    paddingInline: exports.RenderStyleValueSchema.optional(),
+    margin: exports.RenderStyleValueSchema.optional(),
+    marginBlockStart: exports.RenderStyleValueSchema.optional(),
+    marginBlockEnd: exports.RenderStyleValueSchema.optional(),
+    marginInlineStart: exports.RenderStyleValueSchema.optional(),
+    marginInlineEnd: exports.RenderStyleValueSchema.optional(),
+    display: zod_1.z
+        .enum([
+        "none",
+        "block",
+        "inline",
+        "inline-block",
+        "flex",
+        "inline-flex",
+        "grid",
+        "contents",
+    ])
+        .optional(),
+    gap: exports.RenderStyleValueSchema.optional(),
+    rowGap: exports.RenderStyleValueSchema.optional(),
+    columnGap: exports.RenderStyleValueSchema.optional(),
+    background: exports.RenderStyleValueSchema.optional(),
+    color: exports.RenderStyleValueSchema.optional(),
+    borderColor: exports.RenderStyleValueSchema.optional(),
+    borderWidth: exports.RenderStyleValueSchema.optional(),
+    borderStyle: zod_1.z.enum(["none", "solid", "dashed", "dotted"]).optional(),
+    borderRadius: exports.RenderStyleValueSchema.optional(),
+    boxShadow: exports.RenderStyleValueSchema.optional(),
+    fontSize: exports.RenderStyleValueSchema.optional(),
+    fontFamily: exports.RenderStyleValueSchema.optional(),
+    fontWeight: exports.RenderStyleValueSchema.optional(),
+    lineHeight: exports.RenderStyleValueSchema.optional(),
+    textAlign: zod_1.z.enum(["start", "center", "end", "left", "right"]).optional(),
+    whiteSpace: zod_1.z
+        .enum(["normal", "nowrap", "pre", "pre-wrap", "pre-line", "break-spaces"])
+        .optional(),
+    overflow: zod_1.z
+        .enum(["visible", "hidden", "auto", "scroll", "clip"])
+        .optional(),
+    overflowX: zod_1.z
+        .enum(["visible", "hidden", "auto", "scroll", "clip"])
+        .optional(),
+    overflowY: zod_1.z
+        .enum(["visible", "hidden", "auto", "scroll", "clip"])
+        .optional(),
+    position: zod_1.z
+        .enum(["static", "relative", "absolute", "sticky", "fixed"])
+        .optional(),
+    inset: exports.RenderStyleValueSchema.optional(),
+    top: exports.RenderStyleValueSchema.optional(),
+    right: exports.RenderStyleValueSchema.optional(),
+    bottom: exports.RenderStyleValueSchema.optional(),
+    left: exports.RenderStyleValueSchema.optional(),
+    gridTemplateColumns: exports.RenderStyleValueSchema.optional(),
+    gridColumn: exports.RenderStyleValueSchema.optional(),
+    gridRow: exports.RenderStyleValueSchema.optional(),
+    flex: exports.RenderStyleValueSchema.optional(),
+    flexDirection: zod_1.z
+        .enum(["row", "row-reverse", "column", "column-reverse"])
+        .optional(),
+    flexWrap: zod_1.z.enum(["nowrap", "wrap", "wrap-reverse"]).optional(),
+    alignItems: zod_1.z
+        .enum(["start", "center", "end", "stretch", "baseline"])
+        .optional(),
+    justifyContent: zod_1.z
+        .enum([
+        "start",
+        "center",
+        "end",
+        "space-between",
+        "space-around",
+        "space-evenly",
+    ])
+        .optional(),
+    flexGrow: zod_1.z.number().finite().nonnegative().optional(),
+    flexShrink: zod_1.z.number().finite().nonnegative().optional(),
+    alignSelf: zod_1.z.enum(["auto", "start", "center", "end", "stretch"]).optional(),
+    justifySelf: zod_1.z
+        .enum(["auto", "start", "center", "end", "stretch"])
+        .optional(),
+    objectFit: zod_1.z
+        .enum(["contain", "cover", "fill", "none", "scale-down"])
+        .optional(),
+    opacity: zod_1.z.number().finite().min(0).max(1).optional(),
+})
+    .strict();
 const requireRef = (reference, expectedKind, path, context) => {
     if (!reference)
         return;
     if (reference.kind !== expectedKind) {
         context.addIssue({
-            code: 'custom',
-            path: [...path, 'kind'],
-            message: `${path.join('.')} must reference ${expectedKind}.`,
+            code: "custom",
+            path: [...path, "kind"],
+            message: `${path.join(".")} must reference ${expectedKind}.`,
         });
     }
 };
@@ -134,22 +289,22 @@ const requirePinnedOwnedRef = (reference, expectedKind, path, context) => {
         return;
     if (reference.version === undefined) {
         context.addIssue({
-            code: 'custom',
-            path: [...path, 'version'],
-            message: `${path.join('.')} must pin a version.`,
+            code: "custom",
+            path: [...path, "version"],
+            message: `${path.join(".")} must pin a version.`,
         });
     }
     if (reference.ownerRepo === undefined) {
         context.addIssue({
-            code: 'custom',
-            path: [...path, 'ownerRepo'],
-            message: `${path.join('.')} must declare its owner repository.`,
+            code: "custom",
+            path: [...path, "ownerRepo"],
+            message: `${path.join(".")} must declare its owner repository.`,
         });
     }
 };
 exports.RenderNodeSchema = zod_1.z
     .object({
-    contract: zod_1.z.literal('RenderNode'),
+    contract: zod_1.z.literal("RenderNode"),
     nodeId: common_1.ContractIdentifierSchema,
     kind: exports.RenderNodeKindSchema,
     version: common_1.ContractVersionSchema,
@@ -168,43 +323,60 @@ exports.RenderNodeSchema = zod_1.z
     activation: exports.RenderActivationSchema,
     lifecycle: exports.RenderLifecycleSchema,
     layout: exports.RenderLayoutSchema,
+    style: exports.RenderStyleSchema.optional(),
     responsive: zod_1.z.array(exports.RenderResponsiveRuleSchema),
     accessRef: common_1.EntityRefSchema.optional(),
     evidenceRef: common_1.EntityRefSchema.optional(),
     state: exports.RenderNodeStateSchema,
     renderModel: common_1.JsonObjectSchema,
+    repeat: zod_1.z
+        .object({
+        source: page_expression_1.PageExpressionSchema,
+        keyPath: page_expression_1.PageValuePathSchema.min(1),
+        limit: zod_1.z.number().int().min(1).max(1000).default(200),
+    })
+        .strict()
+        .optional(),
 })
     .strict()
     .superRefine((node, context) => {
-    requireRef(node.pageRef, 'page', ['pageRef'], context);
-    requirePinnedOwnedRef(node.capabilityRef, 'capability', ['capabilityRef'], context);
-    requirePinnedOwnedRef(node.providerRef, 'view-provider', ['providerRef'], context);
-    requireRef(node.accessRef, 'access-policy', ['accessRef'], context);
-    requireRef(node.evidenceRef, 'evidence', ['evidenceRef'], context);
+    requireRef(node.pageRef, "page", ["pageRef"], context);
+    requirePinnedOwnedRef(node.capabilityRef, "capability", ["capabilityRef"], context);
+    requirePinnedOwnedRef(node.providerRef, "view-provider", ["providerRef"], context);
+    requireRef(node.accessRef, "access-policy", ["accessRef"], context);
+    requireRef(node.evidenceRef, "evidence", ["evidenceRef"], context);
     if (node.parentNodeId === node.nodeId) {
         context.addIssue({
-            code: 'custom',
-            path: ['parentNodeId'],
-            message: 'RenderNode cannot be its own parent.',
+            code: "custom",
+            path: ["parentNodeId"],
+            message: "RenderNode cannot be its own parent.",
         });
     }
     if (new Set(node.children).size !== node.children.length) {
-        context.addIssue({ code: 'custom', path: ['children'], message: 'RenderNode children must be unique.' });
+        context.addIssue({
+            code: "custom",
+            path: ["children"],
+            message: "RenderNode children must be unique.",
+        });
     }
     if (node.children.includes(node.nodeId)) {
-        context.addIssue({ code: 'custom', path: ['children'], message: 'RenderNode cannot be its own child.' });
+        context.addIssue({
+            code: "custom",
+            path: ["children"],
+            message: "RenderNode cannot be its own child.",
+        });
     }
-    if (node.surface.frameOwner === 'provider' && !node.providerRef) {
+    if (node.surface.frameOwner === "provider" && !node.providerRef) {
         context.addIssue({
-            code: 'custom',
-            path: ['providerRef'],
-            message: 'Provider-owned surfaces require providerRef.',
+            code: "custom",
+            path: ["providerRef"],
+            message: "Provider-owned surfaces require providerRef.",
         });
     }
 });
 exports.RenderTreeSchema = zod_1.z
     .object({
-    contract: zod_1.z.literal('RenderTree'),
+    contract: zod_1.z.literal("RenderTree"),
     treeId: common_1.ContractIdentifierSchema,
     product: exports.ProductContextSchema,
     rootNodeId: common_1.ContractIdentifierSchema,
@@ -212,30 +384,30 @@ exports.RenderTreeSchema = zod_1.z
 })
     .strict();
 exports.OverlayZIndexLaneSchema = zod_1.z.enum([
-    'popover',
-    'drawer',
-    'modal',
-    'fullscreen',
-    'system',
+    "popover",
+    "drawer",
+    "modal",
+    "fullscreen",
+    "system",
 ]);
 exports.OverlayNodeSchema = zod_1.z
     .object({
-    contract: zod_1.z.literal('OverlayNode'),
+    contract: zod_1.z.literal("OverlayNode"),
     overlayId: common_1.ContractIdentifierSchema,
     renderNode: exports.RenderNodeSchema,
-    presentation: zod_1.z.enum(['drawer', 'modal', 'fullscreen']),
+    presentation: zod_1.z.enum(["drawer", "modal", "fullscreen"]),
     zIndexLane: exports.OverlayZIndexLaneSchema,
     url: zod_1.z
         .object({
         parameter: common_1.ContractIdentifierSchema,
         value: common_1.ContractIdentifierSchema,
-        openMode: zod_1.z.enum(['push', 'replace']),
-        closeMode: zod_1.z.enum(['back', 'replace']),
+        openMode: zod_1.z.enum(["push", "replace"]),
+        closeMode: zod_1.z.enum(["back", "replace"]),
     })
         .strict(),
     focus: zod_1.z
         .object({
-        initial: zod_1.z.enum(['first-interactive', 'container', 'explicit']),
+        initial: zod_1.z.enum(["first-interactive", "container", "explicit"]),
         trap: zod_1.z.boolean(),
     })
         .strict(),
@@ -248,46 +420,48 @@ exports.OverlayNodeSchema = zod_1.z
 })
     .strict()
     .superRefine((value, context) => {
-    if (value.renderNode.kind !== 'overlay') {
+    if (value.renderNode.kind !== "overlay") {
         context.addIssue({
-            code: 'custom',
-            path: ['renderNode', 'kind'],
-            message: 'OverlayNode renderNode.kind must be overlay.',
+            code: "custom",
+            path: ["renderNode", "kind"],
+            message: "OverlayNode renderNode.kind must be overlay.",
         });
     }
     if (value.renderNode.activation.mode !== value.presentation) {
         context.addIssue({
-            code: 'custom',
-            path: ['renderNode', 'activation', 'mode'],
-            message: 'OverlayNode presentation must match the RenderNode activation mode.',
+            code: "custom",
+            path: ["renderNode", "activation", "mode"],
+            message: "OverlayNode presentation must match the RenderNode activation mode.",
         });
     }
-    if (value.presentation === 'drawer' && value.zIndexLane !== 'drawer') {
+    if (value.presentation === "drawer" && value.zIndexLane !== "drawer") {
         context.addIssue({
-            code: 'custom',
-            path: ['zIndexLane'],
-            message: 'Drawer overlays must use the drawer z-index lane.',
+            code: "custom",
+            path: ["zIndexLane"],
+            message: "Drawer overlays must use the drawer z-index lane.",
         });
     }
-    if (value.presentation === 'modal' && value.zIndexLane !== 'modal') {
+    if (value.presentation === "modal" && value.zIndexLane !== "modal") {
         context.addIssue({
-            code: 'custom',
-            path: ['zIndexLane'],
-            message: 'Modal overlays must use the modal z-index lane.',
+            code: "custom",
+            path: ["zIndexLane"],
+            message: "Modal overlays must use the modal z-index lane.",
         });
     }
-    if (value.presentation === 'fullscreen' && value.zIndexLane !== 'fullscreen' && value.zIndexLane !== 'system') {
+    if (value.presentation === "fullscreen" &&
+        value.zIndexLane !== "fullscreen" &&
+        value.zIndexLane !== "system") {
         context.addIssue({
-            code: 'custom',
-            path: ['zIndexLane'],
-            message: 'Fullscreen overlays must use the fullscreen or system z-index lane.',
+            code: "custom",
+            path: ["zIndexLane"],
+            message: "Fullscreen overlays must use the fullscreen or system z-index lane.",
         });
     }
 });
 const ProductPathSchema = zod_1.z
     .string()
     .trim()
-    .regex(/^\/(?!\/)/, 'Expected an application-relative path.');
+    .regex(/^\/(?!\/)/, "Expected an application-relative path.");
 exports.ApplicationHandoffEndpointSchema = zod_1.z
     .object({
     product: exports.ProductContextSchema,
@@ -301,7 +475,7 @@ exports.ApplicationHandoffEndpointSchema = zod_1.z
     .strict();
 exports.ApplicationHandoffSchema = zod_1.z
     .object({
-    contract: zod_1.z.literal('ApplicationHandoff'),
+    contract: zod_1.z.literal("ApplicationHandoff"),
     handoffId: common_1.ContractIdentifierSchema,
     source: exports.ApplicationHandoffEndpointSchema,
     target: exports.ApplicationHandoffEndpointSchema,
@@ -311,17 +485,18 @@ exports.ApplicationHandoffSchema = zod_1.z
 })
     .strict()
     .superRefine((value, context) => {
-    if (value.source.product === value.target.product && value.source.pageId === value.target.pageId) {
+    if (value.source.product === value.target.product &&
+        value.source.pageId === value.target.pageId) {
         context.addIssue({
-            code: 'custom',
-            path: ['target'],
-            message: 'ApplicationHandoff target must identify a different product page.',
+            code: "custom",
+            path: ["target"],
+            message: "ApplicationHandoff target must identify a different product page.",
         });
     }
 });
 exports.ViewProviderDescriptorSchema = zod_1.z
     .object({
-    contract: zod_1.z.literal('ViewProviderDescriptor'),
+    contract: zod_1.z.literal("ViewProviderDescriptor"),
     providerId: common_1.ContractIdentifierSchema,
     providerVersion: common_1.ContractIdentifierSchema,
     ownerRepo: common_1.ContractIdentifierSchema,
@@ -329,15 +504,29 @@ exports.ViewProviderDescriptorSchema = zod_1.z
     rendererKey: common_1.ContractIdentifierSchema,
     renderModelSchemaRef: common_1.ContractIdentifierSchema,
     intentSchemaRef: common_1.ContractIdentifierSchema.optional(),
-    loading: zod_1.z.enum(['eager', 'lazy', 'viewport', 'on-activation']),
-    stateOwner: zod_1.z.enum(['host', 'provider', 'external']),
+    loading: zod_1.z.enum(["eager", "lazy", "viewport", "on-activation"]),
+    stateOwner: zod_1.z.enum(["host", "provider", "external"]),
     supportedPageTypes: zod_1.z.array(common_1.ContractIdentifierSchema).min(1),
     supportedSurfaces: zod_1.z
-        .array(zod_1.z.enum(['page', 'workspace', 'view', 'record', 'action', 'overlay', 'agent']))
+        .array(zod_1.z.enum([
+        "page",
+        "workspace",
+        "view",
+        "record",
+        "action",
+        "overlay",
+        "agent",
+    ]))
         .min(1),
-    frameOwner: zod_1.z.enum(['host', 'provider', 'none']),
-    sideEffects: zod_1.z
-        .array(zod_1.z.enum(['network', 'storage', 'navigation', 'worker', 'websocket'])),
+    frameOwner: zod_1.z.enum(["host", "provider", "none"]),
+    sideEffects: zod_1.z.array(zod_1.z.enum([
+        "network",
+        "storage",
+        "navigation",
+        "clipboard",
+        "worker",
+        "websocket",
+    ])),
     sideEffectAdapterRef: common_1.EntityRefSchema.optional(),
     lifecycle: zod_1.z
         .object({
@@ -358,29 +547,39 @@ exports.ViewProviderDescriptorSchema = zod_1.z
 })
     .strict()
     .superRefine((provider, context) => {
-    requirePinnedOwnedRef(provider.capabilityRef, 'capability', ['capabilityRef'], context);
-    requirePinnedOwnedRef(provider.sideEffectAdapterRef, 'side-effect-adapter', ['sideEffectAdapterRef'], context);
-    requireRef(provider.accessRef, 'access-policy', ['accessRef'], context);
-    requireRef(provider.evidenceRef, 'evidence', ['evidenceRef'], context);
+    requirePinnedOwnedRef(provider.capabilityRef, "capability", ["capabilityRef"], context);
+    requirePinnedOwnedRef(provider.sideEffectAdapterRef, "side-effect-adapter", ["sideEffectAdapterRef"], context);
+    requireRef(provider.accessRef, "access-policy", ["accessRef"], context);
+    requireRef(provider.evidenceRef, "evidence", ["evidenceRef"], context);
     if (provider.capabilityRef.version === undefined) {
         context.addIssue({
-            code: 'custom',
-            path: ['capabilityRef', 'version'],
-            message: 'Provider capabilityRef must pin an active capability version.',
+            code: "custom",
+            path: ["capabilityRef", "version"],
+            message: "Provider capabilityRef must pin an active capability version.",
         });
     }
-    if (provider.frameOwner === 'provider' && provider.stateOwner === 'host' && !provider.lifecycle.preserveMount) {
+    if (provider.frameOwner === "provider" &&
+        provider.stateOwner === "host" &&
+        !provider.lifecycle.preserveMount) {
         context.addIssue({
-            code: 'custom',
-            path: ['lifecycle', 'preserveMount'],
-            message: 'Host-owned state on a provider-owned frame must preserve the provider mount.',
+            code: "custom",
+            path: ["lifecycle", "preserveMount"],
+            message: "Host-owned state on a provider-owned frame must preserve the provider mount.",
         });
     }
     if (provider.sideEffects.length > 0 && !provider.sideEffectAdapterRef) {
-        context.addIssue({ code: 'custom', path: ['sideEffectAdapterRef'], message: 'Providers with side effects require a pinned side-effect adapter.' });
+        context.addIssue({
+            code: "custom",
+            path: ["sideEffectAdapterRef"],
+            message: "Providers with side effects require a pinned side-effect adapter.",
+        });
     }
     if (provider.sideEffects.length === 0 && provider.sideEffectAdapterRef) {
-        context.addIssue({ code: 'custom', path: ['sideEffectAdapterRef'], message: 'Pure providers cannot declare a side-effect adapter.' });
+        context.addIssue({
+            code: "custom",
+            path: ["sideEffectAdapterRef"],
+            message: "Pure providers cannot declare a side-effect adapter.",
+        });
     }
 });
 //# sourceMappingURL=render.js.map