@vibesdotdev/vessel 0.0.0-stage → 1.0.0-rc.2

package/dist/schemas.d.ts.map

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

package/dist/schemas.js

@@ -0,0 +1,661 @@
+import * as z from 'zod/v4';
+import { parseVesselValue } from "./boundary.js";
+import { RuntimeDescriptorSchema } from '@vibesdotdev/kernel/schemas/descriptor';
+export const VESSEL_ROUTE_PARAM_LIMIT = 16;
+export const VESSEL_WORKSPACE_RECEIPT_LIMIT = 8;
+export const VESSEL_WORKSPACE_STATE_SCHEMA_VERSION = 1;
+/**
+ * Stable host-owned identity for the runtime place pinned to one Vessel window.
+ * The place owner resolves this id; Vessel only preserves it without importing
+ * runtime-place or leaking it into owner-owned route state.
+ */
+export const vesselRuntimePlaceIdSchema = z
+    .string()
+    .min(1)
+    .max(240)
+    .regex(/^[A-Za-z0-9._:-]+$/, 'Runtime place identity may contain only letters, numbers, dot, underscore, colon, and dash.');
+export const vesselPrimitiveValueSchema = z.union([
+    z.string().max(512),
+    z.number().finite(),
+    z.boolean(),
+    z.null()
+]);
+const forbiddenPersistedParamKey = /(task|status|priority|assignee|dependency|sync|replica|cloud|native|handle|secret|token|content|body|payload|data)/i;
+const referenceOrPresentationParamKey = /(id|ref|path|route|view|mode|tab|index|line|column|offset|zoom|width|height|^x$|^y$|^cwd$)$/i;
+/**
+ * Small, serializable navigation state. Values stay primitive so a return point
+ * can hold owner references without becoming a copy of owner-domain records.
+ */
+export const vesselRouteStateSchema = z
+    .record(z.string().min(1).max(80), vesselPrimitiveValueSchema)
+    .superRefine((state, ctx) => {
+    const keys = Object.keys(state);
+    if (keys.length > VESSEL_ROUTE_PARAM_LIMIT) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `Route state is limited to ${VESSEL_ROUTE_PARAM_LIMIT} primitive parameters.`
+        });
+    }
+    for (const key of keys) {
+        if (forbiddenPersistedParamKey.test(key) || !referenceOrPresentationParamKey.test(key)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: [key],
+                message: `Route parameter '${key}' is not a reference or presentation parameter.`
+            });
+        }
+    }
+});
+export const vesselOwnerRefSchema = z.object({
+    packageName: z.string().min(1),
+    entrypoint: z.string().min(1).optional(),
+    specPath: z.string().min(1).optional(),
+    runtimeKind: z.string().min(1).optional(),
+    runtimeId: z.string().min(1).optional()
+});
+export const vesselAppAccentSchema = z.enum([
+    'teal',
+    'amber',
+    'azure',
+    'blue',
+    'cyan',
+    'lime',
+    'rose',
+    'violet',
+    'neutral'
+]);
+/** Semantic identity is always usable without resolving rich artwork. */
+export const vesselAppIdentitySchema = z
+    .object({
+    glyph: z.string().regex(/^[a-z0-9-]+:[a-z0-9-]+$/, 'Use a namespaced icon token.'),
+    artworkId: z.string().min(1).optional(),
+    accent: vesselAppAccentSchema.default('neutral')
+})
+    .strict();
+const vesselLegacyIconSchema = z
+    .object({
+    name: z
+        .string()
+        .regex(/^[a-z0-9-]+:[a-z0-9-]+$/, 'Use a namespaced icon token.')
+        .optional(),
+    tone: z.enum(['teal', 'amber', 'blue', 'rose', 'neutral']).default('neutral')
+})
+    .strict();
+function normalizeLegacyVesselIcon(icon) {
+    return vesselAppIdentitySchema.parse({
+        glyph: icon?.name ?? 'lucide:box',
+        accent: icon?.tone ?? 'neutral'
+    });
+}
+export const vesselAppCategorySchema = z.enum([
+    'app',
+    'feature',
+    'agent',
+    'service',
+    'tool',
+    'settings',
+    'docs',
+    'runtime',
+    'audit'
+]);
+export const vesselWorkLocationSchema = z.enum(['browser', 'computer', 'cloud', 'vessel']);
+export const vesselPlatformComponentRefSchema = z.object({
+    id: z.string().min(1),
+    version: z.string().min(1).default('latest'),
+    origin: z.string().min(1).optional(),
+    props: z.record(z.string(), z.unknown()).default({})
+});
+export const vesselLaunchTargetSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('svelte-component'),
+        import: z.string().min(1),
+        exportName: z.string().min(1).optional()
+    }),
+    z
+        .object({
+        type: z.literal('vessel-surface'),
+        surfaceId: z.string().min(1),
+        initialState: vesselRouteStateSchema.optional()
+    })
+        .strict(),
+    z.object({ type: z.literal('sveltekit-route'), href: z.string().min(1) }),
+    z.object({
+        type: z.literal('runtime-client'),
+        clientId: z.string().min(1),
+        view: z.enum(['default', 'inspector']).default('default')
+    }),
+    z.object({ type: z.literal('tui-app'), route: z.string().min(1) }),
+    z.object({ type: z.literal('tool'), toolId: z.string().min(1) }),
+    z.object({ type: z.literal('config-manifest'), manifestId: z.string().min(1) }),
+    z.object({ type: z.literal('docs-topic'), topicId: z.string().min(1) }),
+    z.object({
+        type: z.literal('runtime-descriptor'),
+        kind: z.string().min(1),
+        id: z.string().min(1)
+    }),
+    z.object({
+        type: z.literal('platform-component'),
+        componentId: z.string().min(1),
+        version: z.string().min(1).default('latest'),
+        origin: z.string().min(1).optional(),
+        props: z.record(z.string(), z.unknown()).default({})
+    }),
+    z.object({
+        type: z.literal('applet-artifact'),
+        artifactId: z.string().min(1),
+        componentRef: vesselPlatformComponentRefSchema.optional(),
+        browserRuntime: z.boolean().default(false)
+    }),
+    z.object({ type: z.literal('external-url'), href: z.string().url() })
+]);
+export const vesselAvailabilitySchema = z.object({
+    status: z.enum(['available', 'degraded', 'unavailable', 'unknown']).default('unknown'),
+    summary: z.string().default('Not checked'),
+    lastCheckedAt: z.string().datetime().optional()
+});
+export const vesselWindowDefaultsSchema = z.object({
+    width: z.number().int().min(280).default(720),
+    height: z.number().int().min(220).default(460),
+    x: z.number().int().min(0).default(96),
+    y: z.number().int().min(0).default(88),
+    minWidth: z.number().int().min(240).default(360),
+    minHeight: z.number().int().min(180).default(260)
+});
+export const vesselDefaultWindowDefaults = {
+    width: 720,
+    height: 460,
+    x: 96,
+    y: 88,
+    minWidth: 360,
+    minHeight: 260
+};
+/**
+ * Optional I/O ports declared on a vessel/app (xyflow Handles / magnetic wiring).
+ * Prefer this over tag heuristics when apps/wrappers know their event schemas.
+ * Shape mirrors `vesselAppPortSchema` in shell/ports.ts without a circular import.
+ */
+export const vesselAppPortDeclarationSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    direction: z.enum(['input', 'output']),
+    schema: z
+        .object({
+        mediaType: z.string().min(1).default('application/json'),
+        schemaId: z.string().min(1).optional(),
+        shape: z.enum(['any', 'text', 'json', 'event', 'stream', 'binary']).default('any')
+    })
+        .default({ mediaType: 'application/json', shape: 'any' }),
+    multiple: z.boolean().default(true),
+    required: z.boolean().default(false)
+});
+export const vesselAppDescriptorSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/app'),
+    name: z.string().min(1),
+    description: z.string().default(''),
+    owner: vesselOwnerRefSchema,
+    identity: vesselAppIdentitySchema.optional(),
+    /** @deprecated Transitional ingress only. New owner descriptors use `identity`. */
+    icon: vesselLegacyIconSchema.optional(),
+    category: vesselAppCategorySchema,
+    launch: vesselLaunchTargetSchema,
+    availability: vesselAvailabilitySchema.default({ status: 'unknown', summary: 'Not checked' }),
+    defaultWindow: vesselWindowDefaultsSchema.default(vesselDefaultWindowDefaults),
+    tags: z.array(z.string()).default([]),
+    workLocations: z.array(vesselWorkLocationSchema).default([]),
+    readinessAreaIds: z.array(z.string()).default([]),
+    setupStepIds: z.array(z.string()).default([]),
+    /** Declared I/O ports (preferred). When set, replaces tag-heuristic extras. */
+    ports: z.array(vesselAppPortDeclarationSchema).optional()
+}).transform(({ icon, ...app }) => ({
+    ...app,
+    identity: app.identity ?? normalizeLegacyVesselIcon(icon)
+}));
+export const vesselEvidenceSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('runtime-query'),
+        kind: z.string().min(1),
+        id: z.string().optional(),
+        resultSummary: z.string().min(1)
+    }),
+    z.object({
+        type: z.literal('command'),
+        cwd: z.string().min(1),
+        command: z.string().min(1),
+        exitCode: z.number().int(),
+        summary: z.string().min(1)
+    }),
+    z.object({
+        type: z.literal('http'),
+        method: z.string().min(1),
+        url: z.string().min(1),
+        status: z.number().int(),
+        summary: z.string().min(1)
+    }),
+    z.object({
+        type: z.literal('screenshot'),
+        path: z.string().min(1),
+        viewport: z.string().min(1).optional(),
+        summary: z.string().min(1)
+    }),
+    z.object({
+        type: z.literal('source'),
+        path: z.string().min(1),
+        line: z.number().int().min(1).optional(),
+        summary: z.string().min(1)
+    }),
+    z.object({
+        type: z.literal('spec'),
+        path: z.string().min(1),
+        heading: z.string().optional(),
+        summary: z.string().min(1)
+    })
+]);
+export const vesselNextActionSchema = z.object({
+    label: z.string().min(1),
+    href: z.string().optional(),
+    command: z.string().optional()
+});
+export const vesselReadinessStatusSchema = z.enum([
+    'ready',
+    'needs-setup',
+    'planned',
+    'blocked',
+    'unknown'
+]);
+export const vesselReadinessAreaSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/readiness-area'),
+    label: z.string().min(1),
+    userPromise: z.string().min(1),
+    status: vesselReadinessStatusSchema,
+    summary: z.string().min(1),
+    owner: vesselOwnerRefSchema,
+    targetKinds: z.array(z.string()).default([]),
+    evidence: z.array(vesselEvidenceSchema).default([]),
+    linkedFindingIds: z.array(z.string()).default([]),
+    upstreamWorkItemIds: z.array(z.string()).default([]),
+    proofGate: z.string().min(1),
+    nextAction: vesselNextActionSchema.optional()
+});
+export const vesselSetupStepSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/setup-step'),
+    areaId: z.string().min(1),
+    order: z.number().int().min(0).default(0),
+    label: z.string().min(1),
+    userAction: z.string().min(1),
+    userResult: z.string().min(1),
+    place: z.enum(['browser', 'computer', 'cloud', 'vessel', 'vibes']),
+    status: vesselReadinessStatusSchema,
+    owner: vesselOwnerRefSchema,
+    evidence: z.array(vesselEvidenceSchema).default([]),
+    upstreamWorkItemIds: z.array(z.string()).default([]),
+    proofGate: z.string().min(1),
+    nextAction: vesselNextActionSchema.optional(),
+    falsifier: z.string().optional()
+}).superRefine((step, ctx) => {
+    if (step.status !== 'ready')
+        return;
+    if (step.evidence.length === 0 || !step.falsifier) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['evidence'],
+            message: 'Ready setup steps require evidence and a falsifier.'
+        });
+    }
+});
+export const vesselAuditTargetSchema = z.object({
+    kind: z.string().min(1),
+    id: z.string().min(1),
+    label: z.string().min(1)
+});
+export const vesselAuditFindingSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/audit-finding'),
+    lensId: z.string().min(1),
+    target: vesselAuditTargetSchema,
+    status: z.enum(['pass', 'warn', 'fail', 'unknown']),
+    severity: z.enum(['info', 'low', 'medium', 'high', 'blocker']),
+    title: z.string().min(1),
+    summary: z.string().min(1),
+    owner: vesselOwnerRefSchema,
+    evidence: z.array(vesselEvidenceSchema).default([]),
+    falsifier: z.string().optional(),
+    nextAction: vesselNextActionSchema.optional(),
+    createdAt: z.string().datetime()
+}).superRefine((finding, ctx) => {
+    if (finding.status !== 'pass')
+        return;
+    if (finding.evidence.length === 0 ||
+        !finding.evidence.some((evidence) => evidence.type !== 'spec')) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['evidence'],
+            message: 'Passing audit findings require reproducible evidence beyond a spec citation.'
+        });
+    }
+    if (!finding.falsifier) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['falsifier'],
+            message: 'Passing audit findings require a falsifier.'
+        });
+    }
+});
+export const vesselAuditLensDescriptorSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/audit-lens'),
+    name: z.string().min(1),
+    description: z.string().min(1),
+    owner: vesselOwnerRefSchema,
+    targetKinds: z.array(z.string().min(1)).min(1),
+    surfaces: z.array(z.string().min(1)).default([]),
+    severityModel: z.string().min(1),
+    evidenceRequired: z.array(z.string().min(1)).min(1)
+});
+export const vesselSurfaceAudienceSchema = z.enum([
+    'workspace-user',
+    'builder',
+    'host-integrator',
+    'narrow-reviewer'
+]);
+export const vesselSurfaceKindSchema = z.enum(['route', 'component', 'window', 'concept']);
+export const vesselTechnicalLanguagePolicySchema = z.enum(['hide', 'setup-detail', 'allow']);
+export const vesselSurfaceContractSchema = z
+    .object({
+    apiVersion: z.string().min(1),
+    stateSchemaId: z.string().min(1),
+    stateSchemaVersion: z.number().int().positive(),
+    stateSchema: z.instanceof(z.ZodType)
+})
+    .strict();
+export const vesselSurfaceCapabilitySchema = z
+    .object({
+    id: z.string().min(1),
+    reason: z.string().min(1),
+    /** Optional fixed runtime asset id selected by the surface owner. */
+    selectorId: z.string().min(1).optional(),
+    /** Optional route-state key selecting the exact implementation id. */
+    selectorParam: z.string().min(1).optional()
+})
+    .strict()
+    .refine((capability) => !(capability.selectorId && capability.selectorParam), {
+    message: 'A surface capability cannot declare both selectorId and selectorParam.'
+});
+export const vesselSurfaceActivationSchema = z.enum(['on-open', 'on-restore', 'background']);
+export const vesselSurfaceExecutionSchema = z.enum(['host-trusted', 'isolated-frame']);
+export const vesselSurfaceDescriptorSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/surface'),
+    label: z.string().min(1),
+    owner: vesselOwnerRefSchema,
+    contract: vesselSurfaceContractSchema,
+    activation: vesselSurfaceActivationSchema,
+    execution: vesselSurfaceExecutionSchema,
+    requiredCapabilities: z.array(vesselSurfaceCapabilitySchema),
+    optionalCapabilities: z.array(vesselSurfaceCapabilitySchema),
+    readinessCheckIds: z.array(z.string().min(1)).default([]),
+    surfaceKind: vesselSurfaceKindSchema,
+    route: z.string().min(1).optional(),
+    primaryAudience: vesselSurfaceAudienceSchema,
+    secondaryAudiences: z.array(vesselSurfaceAudienceSchema).default([]),
+    defaultSurface: z.boolean().default(false),
+    technicalLanguagePolicy: vesselTechnicalLanguagePolicySchema,
+    promotionGate: z.string().min(1)
+}).strict();
+export const vesselVisualAssetRoleSchema = z.enum(['app-icon', 'product-icon', 'wallpaper']);
+export const vesselVisualAssetPurposeSchema = z.enum([
+    'compact',
+    'hero',
+    'wallpaper',
+    'native',
+    'source'
+]);
+export const vesselVisualAssetThemeSchema = z.enum(['any', 'light', 'dark']);
+export const vesselVisualAssetMaskSchema = z.enum([
+    'square',
+    'rounded-rectangle',
+    'squircle',
+    'circle'
+]);
+export const vesselVisualAssetVariantSchema = z
+    .object({
+    id: z.string().min(1),
+    purpose: vesselVisualAssetPurposeSchema,
+    theme: vesselVisualAssetThemeSchema.default('any'),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    mediaType: z.enum(['image/png', 'image/webp', 'image/avif', 'image/x-icon']),
+    digest: z.string().regex(/^sha256:[a-f0-9]{64}$/)
+})
+    .strict();
+/**
+ * Universal presentation metadata only. Packaged bytes are supplied by a
+ * scope-specific loader, so this descriptor never contains a host path or URL.
+ */
+export const vesselVisualAssetDescriptorSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/visual-asset'),
+    label: z.string().min(1),
+    owner: vesselOwnerRefSchema,
+    role: vesselVisualAssetRoleSchema,
+    accessibleLabel: z.string().min(1),
+    delivery: z.literal('bundled').default('bundled'),
+    paletteId: z.string().min(1),
+    variants: z.array(vesselVisualAssetVariantSchema).min(1),
+    supportedMasks: z.array(vesselVisualAssetMaskSchema).default(['square']),
+    safeZone: z.number().min(0.5).max(1).default(0.8),
+    provenance: z
+        .object({
+        recipeId: z.string().min(1),
+        sourceDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/)
+    })
+        .strict()
+}).strict();
+export const vesselWorkspaceReceiptSchema = z
+    .object({
+    receiptId: z.string().min(1),
+    surfaceId: z.string().min(1),
+    sourceSurfaceId: z.string().min(1).optional(),
+    owner: z
+        .object({
+        kind: z.string().min(1),
+        id: z.string().min(1)
+    })
+        .strict(),
+    action: z.enum(['activate', 'navigate', 'execute', 'restore']),
+    outcome: z.enum(['succeeded', 'failed', 'cancelled']),
+    occurredAt: z.string().datetime(),
+    correlationId: z.string().min(1).optional(),
+    evidence: z
+        .object({
+        kind: z.string().min(1),
+        id: z.string().min(1),
+        context: vesselRouteStateSchema.optional()
+    })
+        .strict()
+})
+    .strict();
+export const vesselWorkspaceChronologicalCueSchema = z
+    .object({
+    type: z.enum(['saved', 'changed', 'restored']),
+    occurredAt: z.string().datetime(),
+    surfaceId: z.string().min(1).optional(),
+    receiptId: z.string().min(1).optional()
+})
+    .strict();
+export const vesselWorkspacePresentationSchema = z
+    .object({
+    x: z.number().int().min(0),
+    y: z.number().int().min(0),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    minimized: z.boolean()
+})
+    .strict();
+export const vesselWorkspaceAnchorSchema = z
+    .object({
+    surfaceId: z.string().min(1),
+    /** Optional for backwards compatibility with return points saved before place pinning. */
+    runtimePlaceId: vesselRuntimePlaceIdSchema.optional(),
+    routeParams: vesselRouteStateSchema.default({}),
+    presentation: vesselWorkspacePresentationSchema
+})
+    .strict();
+export const vesselWorkspaceFocusSchema = z
+    .object({
+    surfaceId: z.string().min(1),
+    ordinal: z.number().int().min(0)
+})
+    .strict();
+export const vesselWorkspaceIdSchema = z
+    .string()
+    .min(1)
+    .max(240)
+    .regex(/^[A-Za-z0-9._:-]+$/, 'Workspace identity may contain only letters, numbers, dot, underscore, colon, and dash.');
+/**
+ * Device-local return projection. It contains surface references and compact
+ * presentation state only; feature records remain at their owning runtime kinds.
+ */
+export const vesselWorkspaceStateSchema = z
+    .object({
+    schemaVersion: z.literal(VESSEL_WORKSPACE_STATE_SCHEMA_VERSION),
+    workspaceId: vesselWorkspaceIdSchema,
+    revision: z.number().int().positive(),
+    savedAt: z.string().datetime(),
+    anchors: z.array(vesselWorkspaceAnchorSchema).max(64),
+    lastFocus: vesselWorkspaceFocusSchema.optional(),
+    chronologicalCue: vesselWorkspaceChronologicalCueSchema,
+    receipts: z.array(vesselWorkspaceReceiptSchema).max(VESSEL_WORKSPACE_RECEIPT_LIMIT).default([])
+})
+    .strict()
+    .superRefine((state, ctx) => {
+    const receiptsById = new Map();
+    for (const [index, receipt] of state.receipts.entries()) {
+        if (receiptsById.has(receipt.receiptId)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['receipts', index, 'receiptId'],
+                message: 'Receipt ids must be unique within a return point.'
+            });
+        }
+        receiptsById.set(receipt.receiptId, receipt);
+    }
+    const cue = state.chronologicalCue;
+    if (cue.receiptId) {
+        const receipt = receiptsById.get(cue.receiptId);
+        if (!receipt) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['chronologicalCue', 'receiptId'],
+                message: 'Chronological cue must reference a receipt present in this return point.'
+            });
+        }
+        else if (cue.surfaceId && receipt.surfaceId !== cue.surfaceId) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['chronologicalCue', 'surfaceId'],
+                message: 'Chronological cue surface must match its referenced receipt surface.'
+            });
+        }
+    }
+    const lastFocus = state.lastFocus;
+    if (!lastFocus)
+        return;
+    const matching = state.anchors.filter((anchor) => anchor.surfaceId === lastFocus.surfaceId);
+    if (lastFocus.ordinal < matching.length)
+        return;
+    ctx.addIssue({
+        code: 'custom',
+        path: ['lastFocus'],
+        message: 'Last focus must reference an anchor present in this return point.'
+    });
+});
+export const vesselDesignReviewerVerdictSchema = z
+    .object({
+    reviewerId: z.string().min(1),
+    status: z.enum(['approved', 'needs-iteration', 'blocked']),
+    feedback: z.string().min(1),
+    requiredChange: z.string().min(1).optional()
+})
+    .superRefine((verdict, ctx) => {
+    if (verdict.status === 'approved')
+        return;
+    if (!verdict.requiredChange) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['requiredChange'],
+            message: 'Non-approved design review verdicts require a concrete change.'
+        });
+    }
+});
+export const vesselDesignReviewRecordSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/design-review'),
+    surfaceId: z.string().min(1),
+    goal: z.string().min(1),
+    status: z.enum(['approved', 'needs-iteration', 'blocked']),
+    visualMethods: z
+        .array(z.enum(['imagegen-concept', 'real-browser-screenshot', 'component-shot']))
+        .min(1),
+    evidence: z.array(vesselEvidenceSchema).min(1),
+    verdicts: z.array(vesselDesignReviewerVerdictSchema).min(9)
+});
+export const vesselOsStandardDescriptorSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('vessel/os-standard'),
+    label: z.string().min(1),
+    version: z.string().min(1),
+    constitutionGates: z.array(z.string().min(1)).min(1),
+    requiredSurfaceIds: z.array(z.string().min(1)).min(1),
+    promotionGates: z.array(z.string().min(1)).min(1),
+    falsifiers: z.array(z.string().min(1)).min(1)
+});
+export const vesselMountPayloadSchema = z
+    .object({
+    kind: z.literal('vessel/mount-payload').default('vessel/mount-payload'),
+    generatedAt: z.string().datetime(),
+    source: z
+        .object({
+        type: z
+            .enum(['host-supplied', 'runtime-query', 'fixture', 'file'])
+            .default('host-supplied'),
+        label: z.string().min(1).optional()
+    })
+        .default({ type: 'host-supplied' }),
+    apps: z.array(vesselAppDescriptorSchema).default([]),
+    readinessAreas: z.array(vesselReadinessAreaSchema).default([]),
+    setupSteps: z.array(vesselSetupStepSchema).default([]),
+    visualAssets: z.array(vesselVisualAssetDescriptorSchema).default([]),
+    auditFindings: z.array(vesselAuditFindingSchema).default([]),
+    notes: z.array(z.string()).default([])
+})
+    .superRefine((payload, ctx) => {
+    const assets = new Map(payload.visualAssets.map((asset) => [asset.id, asset]));
+    for (const [index, app] of payload.apps.entries()) {
+        const artworkId = app.identity.artworkId;
+        if (!artworkId)
+            continue;
+        const asset = assets.get(artworkId);
+        if (!asset) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['apps', index, 'identity', 'artworkId'],
+                message: `No admitted vessel/visual-asset owns '${artworkId}'.`
+            });
+        }
+        else if (asset.role !== 'app-icon') {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['apps', index, 'identity', 'artworkId'],
+                message: `'${artworkId}' is ${asset.role}, not app-icon artwork.`
+            });
+        }
+    }
+});
+/** Canonical append-order + bounded-history rule for workspace receipts. */
+export function advanceVesselWorkspaceReceipts(current, appended) {
+    return [...current, ...appended].slice(-VESSEL_WORKSPACE_RECEIPT_LIMIT);
+}
+export function parseVesselAppDescriptor(input) {
+    return parseVesselValue(vesselAppDescriptorSchema, input);
+}
+export function parseVesselMountPayload(input) {
+    return parseVesselValue(vesselMountPayloadSchema, input);
+}
+export function parseVesselWorkspaceState(input) {
+    return parseVesselValue(vesselWorkspaceStateSchema, input);
+}
+//# sourceMappingURL=schemas.js.map