@deckflow/deckuse 1.2.0 → 1.3.0

package/dist/core/schema.js

@@ -0,0 +1,798 @@
+import { z } from 'zod';
+export const PROTOCOL_VERSION = '2.0';
+export const protocolVersionSchema = z.literal(PROTOCOL_VERSION);
+export const errorCodeSchema = z.enum([
+    'INVALID_COMMAND',
+    'UNSUPPORTED_VERSION',
+    'WORKSPACE_NOT_FOUND',
+    'DOCUMENT_NOT_FOUND',
+    'ELEMENT_NOT_FOUND',
+    'TARGET_NOT_FOUND',
+    'AMBIGUOUS_REFERENCE',
+    'AMBIGUOUS_NAME',
+    'FORMAT_NOT_SUPPORTED',
+    'FORMAT_NOT_IMPLEMENTED',
+    'VALIDATION_FAILED',
+    'TRANSACTION_CONFLICT',
+    'UNSUPPORTED_CAPABILITY',
+    'IO_ERROR',
+    'INTERNAL_ERROR',
+]);
+export const diagnosticSchema = z
+    .object({
+    severity: z.enum(['info', 'warning', 'error']),
+    code: z.string().min(1),
+    message: z.string().min(1),
+    path: z.array(z.union([z.string(), z.number().int().nonnegative()])).optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+export const elementRefSchema = z
+    .object({
+    documentId: z.string().min(1),
+    elementId: z.string().min(1).optional(),
+    path: z.string().min(1).optional(),
+    revision: z.string().min(1).optional(),
+})
+    .strict()
+    .refine((value) => value.elementId !== undefined || value.path !== undefined, {
+    message: 'elementId or path is required',
+});
+/** Phase-1 semantic address, e.g. slide:6/shape:7 or slide:6/shape:title/text */
+export const targetPathSchema = z.string().min(1);
+/** EMU number, or unit string (`120px`, `5%`, `1.5in`, …). Bare numbers are EMU. */
+export const lengthValueSchema = z.union([z.number(), z.string().min(1)]);
+export const transformSchema = z
+    .object({
+    x: lengthValueSchema.optional(),
+    y: lengthValueSchema.optional(),
+    width: lengthValueSchema.optional(),
+    height: lengthValueSchema.optional(),
+    rotation: z.number().optional(),
+    flipHorizontal: z.boolean().optional(),
+    flipVertical: z.boolean().optional(),
+})
+    .strict();
+export const textRunSchema = z
+    .object({
+    text: z.string(),
+    fontSize: z.number().positive().optional(),
+    fontFamily: z.string().min(1).optional(),
+    textColor: z.string().min(1).optional(),
+    bold: z.boolean().optional(),
+    italic: z.boolean().optional(),
+    underline: z.boolean().optional(),
+})
+    .strict();
+export const textBlockSchema = z
+    .object({
+    /** Plain paragraph text (single run). Ignored when `runs` is set. */
+    text: z.string().optional(),
+    /** Intra-paragraph runs with per-run styling. When set, preferred over `text`. */
+    runs: z.array(textRunSchema).min(1).optional(),
+    fontSize: z.number().positive().optional(),
+    fontFamily: z.string().min(1).optional(),
+    textColor: z.string().min(1).optional(),
+    bold: z.boolean().optional(),
+    italic: z.boolean().optional(),
+    underline: z.boolean().optional(),
+    align: z.enum(['l', 'ctr', 'r', 'just', 'left', 'center', 'right', 'justify']).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.runs === undefined && value.text === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'blocks[] entry requires text or runs',
+            path: ['text'],
+        });
+    }
+});
+export const resolveModeSchema = z.enum(['effective', 'direct', 'both']);
+export const writeScopeSchema = z.enum(['local', 'placeholder', 'layout', 'master', 'theme']);
+const commandBase = {
+    version: protocolVersionSchema,
+    requestId: z.string().min(1).optional(),
+};
+const mutationBase = {
+    workspaceId: z.string().min(1),
+    transactionId: z.string().min(1),
+    dryRun: z.boolean().optional(),
+    expectRevision: z.union([z.string().min(1), z.number().int().positive()]).optional(),
+    reason: z.string().min(1).optional(),
+};
+const initCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('init'),
+    workspaceId: z.string().min(1),
+    format: z.string().min(1),
+    source: z.string().min(1),
+    options: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+const selectorObjectSchema = z
+    .object({
+    kind: z.string().min(1).optional(),
+    name: z.string().min(1).optional(),
+    text: z.string().min(1).optional(),
+    textRegex: z.string().min(1).optional(),
+    id: z.string().min(1).optional(),
+    slide: z.string().min(1).optional(),
+    hasText: z.boolean().optional(),
+})
+    .strict();
+export const selectorSchema = z.union([z.string().min(1), selectorObjectSchema]);
+const statusCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('status'),
+    workspaceId: z.string().min(1),
+})
+    .strict();
+const listCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('list'),
+    workspaceId: z.string().min(1),
+    resource: z.enum([
+        'slides',
+        'shapes',
+        'layouts',
+        'masters',
+        'theme',
+        'paragraphs',
+        'tables',
+        'sections',
+        'styles',
+        'bookmarks',
+    ]),
+    slide: z.number().int().positive().optional(),
+})
+    .strict();
+const getCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('get'),
+    workspaceId: z.string().min(1),
+    target: z.string().min(1),
+    resolve: resolveModeSchema.default('both'),
+    props: z.array(z.string().min(1)).optional(),
+    provenance: z.boolean().optional(),
+})
+    .strict();
+const searchCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('search'),
+    workspaceId: z.string().min(1),
+    kind: z.enum(['text', 'shape']),
+    query: z.string().optional(),
+    name: z.string().min(1).optional(),
+    scope: z.string().min(1).optional(),
+    limit: z.number().int().positive().max(10000).default(100),
+})
+    .strict();
+const inspectCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('inspect'),
+    workspaceId: z.string().min(1),
+    target: z.string().min(1).optional(),
+    ref: elementRefSchema.optional(),
+    depth: z.number().int().min(0).max(100).default(1),
+    visualTree: z.boolean().optional(),
+})
+    .strict();
+const queryCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('query'),
+    workspaceId: z.string().min(1),
+    selector: selectorSchema,
+    limit: z.number().int().positive().max(10000).default(100),
+})
+    .strict();
+const getTextCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('getText'),
+    workspaceId: z.string().min(1),
+    ref: elementRefSchema,
+})
+    .strict();
+const setTextCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('setText'),
+    ref: elementRefSchema.optional(),
+    target: z.string().min(1).optional(),
+    text: z.string().optional(),
+    value: z.string().optional(),
+    /** Rich paragraphs: each block becomes one `a:p` with its own run style. */
+    blocks: z.array(textBlockSchema).min(1).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.blocks === undefined && value.text === undefined && value.value === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'setText requires text, value, or blocks',
+            path: ['text'],
+        });
+    }
+});
+const replaceTextCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('replaceText'),
+    find: z.string().min(1),
+    replace: z.string(),
+    regex: z.boolean().optional(),
+    selector: selectorSchema.optional(),
+    limit: z.number().int().positive().max(10000).optional(),
+})
+    .strict();
+const setPropertiesCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('setProperties'),
+    ref: elementRefSchema.optional(),
+    target: z.string().min(1).optional(),
+    properties: z.record(z.string(), z.unknown()),
+    scope: writeScopeSchema.optional(),
+})
+    .strict();
+const setCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('set'),
+    target: z.string().min(1),
+    properties: z.record(z.string(), z.unknown()),
+    scope: writeScopeSchema.default('local'),
+})
+    .strict();
+const setTransformCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('setTransform'),
+    ref: elementRefSchema.optional(),
+    target: z.string().min(1).optional(),
+    transform: transformSchema,
+})
+    .strict();
+const xfrmSetCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('xfrmSet'),
+    target: z.string().min(1).optional(),
+    slide: z.number().int().positive().optional(),
+    shape: z.union([z.number().int().positive(), z.string().min(1)]).optional(),
+    x: lengthValueSchema.optional(),
+    y: lengthValueSchema.optional(),
+    width: lengthValueSchema.optional(),
+    height: lengthValueSchema.optional(),
+    rotation: z.number().optional(),
+    flipX: z.boolean().optional(),
+    flipY: z.boolean().optional(),
+})
+    .strict();
+const setTableLayoutCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('setTableLayout'),
+    target: targetPathSchema,
+    /** Frame height: `"auto"` uses content heuristics, or an absolute length. */
+    height: z.union([z.literal('auto'), lengthValueSchema]).optional(),
+    /** `content` = measure cells; `equal` = split frame height evenly across rows. */
+    redistribute: z.enum(['equal', 'content']).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.height === undefined && value.redistribute === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'setTableLayout requires height and/or redistribute',
+            path: ['height'],
+        });
+    }
+});
+const zMoveCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('zMove'),
+    target: z.string().min(1),
+    above: z.string().min(1).optional(),
+    below: z.string().min(1).optional(),
+    toFront: z.boolean().optional(),
+    toBack: z.boolean().optional(),
+})
+    .strict();
+const alignElementsCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('alignElements'),
+    slide: z.number().int().positive(),
+    targets: z.array(z.string().min(1)).min(1),
+    mode: z.enum([
+        'left',
+        'right',
+        'top',
+        'bottom',
+        'center-h',
+        'center-v',
+        'distribute-h',
+        'distribute-v',
+    ]),
+    gap: lengthValueSchema.optional(),
+})
+    .strict();
+const addCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('add'),
+    parent: elementRefSchema.optional(),
+    target: z.string().min(1).optional(),
+    element: z.record(z.string(), z.unknown()),
+})
+    .strict();
+const addSlideCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('addSlide'),
+    after: z.number().int().nonnegative().optional(),
+    /** Layout ref: index, layout:N, slide:N, display name, or basename. */
+    layout: z.string().min(1).optional(),
+    name: z.string().min(1).optional(),
+})
+    .strict();
+const setSlideLayoutCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('setSlideLayout'),
+    slide: z.number().int().positive(),
+    /** Layout ref: index, layout:N, slide:N, display name, or basename. */
+    layout: z.string().min(1),
+})
+    .strict();
+const chartDataSchema = z
+    .object({
+    title: z.string().optional(),
+    categories: z.array(z.string()).default([]),
+    series: z
+        .array(z
+        .object({
+        name: z.string().min(1),
+        values: z.array(z.number()),
+        color: z.string().min(1).optional(),
+        /** For combo charts: primary (left) or secondary (right) value axis. */
+        axis: z.enum(['primary', 'secondary']).optional(),
+        /** For combo charts: render this series as bar/column or line. */
+        chart: z.enum(['bar', 'column', 'line']).optional(),
+    })
+        .strict())
+        .min(1),
+})
+    .strict();
+const addShapeCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('addShape'),
+    slide: z.number().int().positive(),
+    shapeType: z.enum([
+        'text',
+        'rect',
+        'rounded-rect',
+        'ellipse',
+        'line',
+        'connector',
+        'elbow',
+        'elbow-connector',
+        'curved-connector',
+        'arrow',
+        'right-arrow',
+        'left-arrow',
+        'up-arrow',
+        'down-arrow',
+        'chevron',
+        'pentagon',
+        'trapezoid',
+        'triangle',
+        'rt-triangle',
+        'circular-arrow',
+        'curved-right-arrow',
+        'curved-left-arrow',
+        'image',
+        'group',
+        'table',
+        'chart',
+        'video',
+        'audio',
+    ]),
+    name: z.string().min(1).optional(),
+    role: z.string().min(1).optional(),
+    x: lengthValueSchema.optional(),
+    y: lengthValueSchema.optional(),
+    width: lengthValueSchema.optional(),
+    height: lengthValueSchema.optional(),
+    /** Rounded-rect corner radius: 0–1 fraction of half the shorter side (OOXML adj). */
+    cornerRadius: z.number().min(0).max(1).optional(),
+    file: z.string().min(1).optional(),
+    text: z.string().optional(),
+    /** Rich paragraphs; when set, preferred over `text`. */
+    blocks: z.array(textBlockSchema).min(1).optional(),
+    /** Vertical text anchor: t|ctr|b (or top|middle|bottom). */
+    anchor: z.enum(['t', 'ctr', 'b', 'top', 'middle', 'bottom']).optional(),
+    /** Text wrapping: square (default) or none. */
+    wrap: z.enum(['square', 'none']).optional(),
+    fill: z
+        .union([
+        z.string().min(1),
+        z
+            .object({
+            color: z.string().min(1),
+            transparency: z.number().optional(),
+            type: z.literal('solid').optional(),
+        })
+            .strict(),
+    ])
+        .optional(),
+    stroke: z
+        .union([
+        z.string().min(1),
+        z
+            .object({
+            color: z.string().min(1).optional(),
+            width: z.number().optional(),
+            dash: z.string().min(1).optional(),
+            headEnd: z.string().min(1).optional(),
+            tailEnd: z.string().min(1).optional(),
+        })
+            .strict(),
+    ])
+        .optional(),
+    rows: z.array(z.array(z.string())).optional(),
+    /** Table visual preset. */
+    theme: z.enum(['minimal', 'zebra']).optional(),
+    /** Column alignments by index: l|ctr|r (or left|center|right). */
+    alignColumns: z.array(z.enum(['l', 'ctr', 'r', 'left', 'center', 'right'])).optional(),
+    chartType: z.enum(['bar', 'column', 'line', 'pie', 'combo']).optional(),
+    data: chartDataSchema.optional(),
+    showDataLabels: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if ((value.shapeType === 'image' || value.shapeType === 'video' || value.shapeType === 'audio') &&
+        !value.file) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `--type ${value.shapeType} requires --file <path> (example: deckuse add shape --slide 1 --type ${value.shapeType} --file ./media)`,
+            path: ['file'],
+        });
+    }
+    if (value.shapeType === 'table' && !value.rows) {
+        ctx.addIssue({
+            code: 'custom',
+            message: '--type table requires --rows \'<json>\' (example: --rows \'[["A","B"],["1","2"]]\')',
+            path: ['rows'],
+        });
+    }
+    if (value.shapeType === 'chart') {
+        if (!value.chartType) {
+            ctx.addIssue({
+                code: 'custom',
+                message: '--type chart requires --chart-type <bar|column|line|pie|combo> (example: --chart-type column --data \'{"categories":["Q1"],"series":[{"name":"S1","values":[1]}]}\')',
+                path: ['chartType'],
+            });
+        }
+        if (!value.data) {
+            ctx.addIssue({
+                code: 'custom',
+                message: '--type chart requires --data \'<json>\' with categories + series (example: --data \'{"categories":["Q1","Q2"],"series":[{"name":"2024","values":[10,20]}]}\')',
+                path: ['data'],
+            });
+        }
+        if (value.chartType === 'combo' && value.data) {
+            const charts = new Set(value.data.series.map((s) => s.chart ?? 'column'));
+            if (!charts.has('line') || ![...charts].some((c) => c === 'bar' || c === 'column')) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: 'combo charts require at least one bar/column series and one line series (set series[].chart)',
+                    path: ['data', 'series'],
+                });
+            }
+        }
+    }
+});
+const addParagraphCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('addParagraph'),
+    /** Insert after this target. Omit to append before the final sectPr. */
+    after: z.string().min(1).optional(),
+    /** Paragraph style id (for example Heading1). Wins over `level` when both are set. */
+    style: z.string().min(1).optional(),
+    /** Heading level 1–9, or 0 for Normal. Ignored when `style` is set. */
+    level: z.number().int().min(0).max(9).optional(),
+    /** Bookmark name so later commands in the same batch can target bookmark:<name>. */
+    name: z.string().min(1).optional(),
+    text: z.string().optional(),
+    /** Rich paragraphs; when set, preferred over `text`. The first block fills this paragraph. */
+    blocks: z.array(textBlockSchema).min(1).optional(),
+})
+    .strict();
+const addTableCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('addTable'),
+    after: z.string().min(1).optional(),
+    name: z.string().min(1).optional(),
+    rows: z.array(z.array(z.string())).min(1),
+})
+    .strict();
+const insertBreakCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('insertBreak'),
+    kind: z.enum(['page']).default('page'),
+    after: z.string().min(1).optional(),
+})
+    .strict();
+const removeCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('remove'),
+    ref: elementRefSchema.optional(),
+    target: z.string().min(1).optional(),
+})
+    .strict();
+const replacePictureCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('replacePicture'),
+    ref: elementRefSchema.optional(),
+    target: z.string().min(1).optional(),
+    path: z.string().min(1).optional(),
+    base64: z.string().min(1).optional(),
+})
+    .strict();
+const duplicateCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('duplicate'),
+    ref: elementRefSchema.optional(),
+    target: z.string().min(1).optional(),
+    parent: elementRefSchema.optional(),
+    index: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const applyTransactionCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('applyTransaction'),
+    operations: z.array(z.record(z.string(), z.unknown())).min(1).max(1000),
+})
+    .strict();
+const exportCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('export'),
+    workspaceId: z.string().min(1),
+    output: z.string().min(1),
+    revision: z.union([z.string().min(1), z.number().int().positive()]).optional(),
+    /** When true, copy existing package.pptx without rebuilding from source/. */
+    fromPackage: z.boolean().optional(),
+})
+    .strict();
+const undoCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('undo'),
+    workspaceId: z.string().min(1),
+    steps: z.number().int().positive().max(1000).default(1),
+})
+    .strict();
+const historyCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('history'),
+    workspaceId: z.string().min(1),
+    limit: z.number().int().positive().max(10000).default(100),
+    offset: z.number().int().nonnegative().max(1000000).default(0),
+    slide: z.number().int().positive().optional(),
+})
+    .strict();
+const validateCommandSchema = z
+    .object({
+    ...commandBase,
+    type: z.literal('validate'),
+    workspaceId: z.string().min(1),
+    level: z.enum(['fast', 'full']).default('full'),
+    package: z.boolean().optional(),
+    relationships: z.boolean().optional(),
+    ids: z.boolean().optional(),
+    render: z.boolean().optional(),
+    slide: z.number().int().positive().optional(),
+})
+    .strict();
+export const atomicCommandSchema = z.discriminatedUnion('type', [
+    setTextCommandSchema,
+    replaceTextCommandSchema,
+    setTransformCommandSchema,
+    setPropertiesCommandSchema,
+    setCommandSchema,
+    xfrmSetCommandSchema,
+    setTableLayoutCommandSchema,
+    zMoveCommandSchema,
+    alignElementsCommandSchema,
+    addCommandSchema,
+    addSlideCommandSchema,
+    setSlideLayoutCommandSchema,
+    addShapeCommandSchema,
+    addParagraphCommandSchema,
+    addTableCommandSchema,
+    insertBreakCommandSchema,
+    removeCommandSchema,
+    replacePictureCommandSchema,
+    duplicateCommandSchema,
+]);
+const batchCommandSchema = z
+    .object({
+    ...commandBase,
+    ...mutationBase,
+    type: z.literal('batch'),
+    atomic: z.boolean().default(true),
+    commands: z.array(atomicCommandSchema).min(1).max(1000),
+})
+    .strict();
+export const commandSchema = z.discriminatedUnion('type', [
+    initCommandSchema,
+    statusCommandSchema,
+    listCommandSchema,
+    getCommandSchema,
+    searchCommandSchema,
+    inspectCommandSchema,
+    queryCommandSchema,
+    getTextCommandSchema,
+    setTextCommandSchema,
+    replaceTextCommandSchema,
+    setTransformCommandSchema,
+    setPropertiesCommandSchema,
+    setCommandSchema,
+    xfrmSetCommandSchema,
+    zMoveCommandSchema,
+    alignElementsCommandSchema,
+    addCommandSchema,
+    addSlideCommandSchema,
+    setSlideLayoutCommandSchema,
+    addShapeCommandSchema,
+    addParagraphCommandSchema,
+    addTableCommandSchema,
+    insertBreakCommandSchema,
+    removeCommandSchema,
+    replacePictureCommandSchema,
+    duplicateCommandSchema,
+    applyTransactionCommandSchema,
+    batchCommandSchema,
+    exportCommandSchema,
+    undoCommandSchema,
+    historyCommandSchema,
+    validateCommandSchema,
+]);
+export const commandJsonSchema = z.toJSONSchema(commandSchema, {
+    target: 'draft-2020-12',
+    reused: 'ref',
+});
+export const propertyValueSchema = z
+    .object({
+    effective: z.unknown().nullable(),
+    direct: z.unknown().nullable(),
+    inherited: z.boolean(),
+    source: z
+        .object({
+        scope: z.enum(['local', 'placeholder', 'layout', 'master', 'theme', 'default']),
+        target: z.string().min(1).optional(),
+        path: z.string().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+    unit: z.string().min(1).optional(),
+})
+    .strict();
+export const commandEnvelopeSchema = z
+    .object({
+    ok: z.boolean(),
+    command: z.string().min(1),
+    revision: z.number().int().nonnegative().optional(),
+    commit: z.string().min(1).optional(),
+    branch: z.string().min(1).optional(),
+    affectedSlides: z.array(z.number().int().positive()).optional(),
+    changedTargets: z.array(z.string().min(1)).optional(),
+    changedParts: z.array(z.string().min(1)).optional(),
+    warnings: z.array(z.string()).optional(),
+    data: z.unknown().optional(),
+    error: z
+        .object({
+        code: z.string().min(1),
+        message: z.string().min(1),
+        target: z.string().min(1).optional(),
+        hint: z.string().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export const initResultSchema = z
+    .object({
+    workspaceId: z.string().min(1),
+    format: z.string().min(1),
+    source: z.string().min(1),
+    revision: z.union([z.string().min(1), z.number().int().positive()]),
+    elementCount: z.number().int().nonnegative(),
+})
+    .strict();
+export const workspaceManifestSchema = z
+    .object({
+    schemaVersion: protocolVersionSchema,
+    workspaceId: z.string().min(1),
+    format: z.string().min(1),
+    source: z.string().min(1),
+    revision: z.string().min(1),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    adapterVersion: z.string().min(1),
+    files: z.array(z
+        .object({
+        path: z.string().min(1),
+        mediaType: z.string().min(1).optional(),
+        checksum: z.string().min(1),
+    })
+        .strict()),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+export const ok = (value, diagnostics = []) => ({
+    ok: true,
+    value,
+    diagnostics,
+});
+export const err = (code, message, diagnostics = [], extra = {}) => ({
+    ok: false,
+    error: {
+        code,
+        message,
+        ...(diagnostics.length > 0 ? { diagnostics } : {}),
+        ...(extra.target ? { target: extra.target } : {}),
+        ...(extra.hint ? { hint: extra.hint } : {}),
+    },
+    diagnostics,
+});
+export const revisionAsNumber = (revision) => {
+    if (revision === undefined)
+        return undefined;
+    if (typeof revision === 'number')
+        return Number.isFinite(revision) ? revision : undefined;
+    const n = Number(revision);
+    return Number.isInteger(n) && n >= 0 ? n : undefined;
+};
+//# sourceMappingURL=schema.js.map