@openlup/platform 0.17.0 → 0.18.0

package/dist/catalog/draftPorts.d.ts

@@ -0,0 +1,18 @@
+import type { CatalogDraftApplyResult, CatalogDraftGetQuery, CatalogDraftListQuery, CatalogDraftPage, CatalogDraftRecord, CatalogDraftRefusal } from "./draftSchemas.js";
+/** Portable adapters accept this actor only after the injected operator authorizer succeeds. */
+export interface CatalogDraftOperator {
+    actorId: string;
+}
+export interface CatalogDraftStorePort {
+    apply(input: {
+        canonicalCommand: string;
+        fingerprint: string;
+        actorId: string;
+    }): Promise<CatalogDraftApplyResult>;
+    get(query: CatalogDraftGetQuery, actorId: string): Promise<CatalogDraftRecord | null>;
+    list(query: CatalogDraftListQuery, actorId: string): Promise<CatalogDraftPage>;
+}
+export declare class CatalogDraftStoreError extends Error {
+    readonly refusal: CatalogDraftRefusal;
+    constructor(refusal: CatalogDraftRefusal);
+}

package/dist/catalog/draftPorts.js

@@ -0,0 +1,8 @@
+export class CatalogDraftStoreError extends Error {
+    refusal;
+    constructor(refusal) {
+        super(refusal.reason);
+        this.refusal = refusal;
+        this.name = "CatalogDraftStoreError";
+    }
+}

package/dist/catalog/draftSchemas.d.ts

@@ -0,0 +1,423 @@
+import { z } from "./validation.js";
+export { CATALOG_DRAFT_MAX_BYTES, CATALOG_DRAFT_MAX_PAGE, canonicalCatalogDraftJson } from "./contracts/draft.js";
+export type { CatalogDraftPayload, CatalogDraftCommand, CatalogDraftRecord, CatalogDraftSummary, CatalogDraftPage, CatalogDraftRefusal, CatalogDraftApplyResult, CatalogDraftGetQuery, CatalogDraftListQuery } from "./contracts/draft.js";
+export declare const catalogDraftPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    product: z.ZodObject<{
+        id: z.ZodGUID;
+        type: z.ZodObject<{
+            key: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strict>;
+        slug: z.ZodOptional<z.ZodString>;
+        primarySkuId: z.ZodOptional<z.ZodGUID>;
+        dimensions: z.ZodArray<z.ZodString>;
+        sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+        documentRevision: z.ZodOptional<z.ZodObject<{
+            id: z.ZodGUID;
+            productId: z.ZodGUID;
+            revisionNo: z.ZodNumber;
+            schemaId: z.ZodString;
+            documentRef: z.ZodString;
+            sourceRef: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    skus: z.ZodArray<z.ZodObject<{
+        id: z.ZodGUID;
+        productId: z.ZodGUID;
+        code: z.ZodOptional<z.ZodString>;
+        options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"choice">;
+            value: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"quantity">;
+            value: z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"boolean">;
+            value: z.ZodBoolean;
+        }, z.core.$strict>], "kind">>;
+        netContent: z.ZodOptional<z.ZodObject<{
+            dimension: z.ZodEnum<{
+                count: "count";
+                mass: "mass";
+                volume: "volume";
+            }>;
+            unscaled: z.ZodString;
+            scale: z.ZodNumber;
+            unit: z.ZodString;
+        }, z.core.$strict>>;
+        identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            scheme: z.ZodString;
+            issuer: z.ZodString;
+            value: z.ZodString;
+            packagingLevel: z.ZodEnum<{
+                unit: "unit";
+                case: "case";
+            }>;
+            quantity: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        grossMass: z.ZodOptional<z.ZodObject<{
+            dimension: z.ZodEnum<{
+                count: "count";
+                mass: "mass";
+                volume: "volume";
+            }>;
+            unscaled: z.ZodString;
+            scale: z.ZodNumber;
+            unit: z.ZodString;
+        }, z.core.$strict>>;
+        priceRef: z.ZodOptional<z.ZodString>;
+        logisticsRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const catalogDraftCommandSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    action: z.ZodEnum<{
+        create: "create";
+        revise: "revise";
+        abandon: "abandon";
+    }>;
+    draftId: z.ZodGUID;
+    commandKey: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    payload: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        product: z.ZodObject<{
+            id: z.ZodGUID;
+            type: z.ZodObject<{
+                key: z.ZodString;
+                version: z.ZodNumber;
+            }, z.core.$strict>;
+            slug: z.ZodOptional<z.ZodString>;
+            primarySkuId: z.ZodOptional<z.ZodGUID>;
+            dimensions: z.ZodArray<z.ZodString>;
+            sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+            documentRevision: z.ZodOptional<z.ZodObject<{
+                id: z.ZodGUID;
+                productId: z.ZodGUID;
+                revisionNo: z.ZodNumber;
+                schemaId: z.ZodString;
+                documentRef: z.ZodString;
+                sourceRef: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        skus: z.ZodArray<z.ZodObject<{
+            id: z.ZodGUID;
+            productId: z.ZodGUID;
+            code: z.ZodOptional<z.ZodString>;
+            options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"choice">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"quantity">;
+                value: z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>], "kind">>;
+            netContent: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                scheme: z.ZodString;
+                issuer: z.ZodString;
+                value: z.ZodString;
+                packagingLevel: z.ZodEnum<{
+                    unit: "unit";
+                    case: "case";
+                }>;
+                quantity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grossMass: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            priceRef: z.ZodOptional<z.ZodString>;
+            logisticsRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const catalogDraftGetQuerySchema: z.ZodObject<{
+    draftId: z.ZodGUID;
+    revision: z.ZodOptional<z.ZodNumber>;
+    commandKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const catalogDraftListQuerySchema: z.ZodObject<{
+    afterDraftId: z.ZodOptional<z.ZodGUID>;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+export declare const catalogDraftSummarySchema: z.ZodObject<{
+    draftId: z.ZodGUID;
+    productId: z.ZodGUID;
+    revision: z.ZodNumber;
+    status: z.ZodEnum<{
+        open: "open";
+        abandoned: "abandoned";
+    }>;
+    commandKey: z.ZodString;
+    fingerprint: z.ZodString;
+    actorId: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
+export declare const catalogDraftRecordSchema: z.ZodObject<{
+    draftId: z.ZodGUID;
+    productId: z.ZodGUID;
+    revision: z.ZodNumber;
+    status: z.ZodEnum<{
+        open: "open";
+        abandoned: "abandoned";
+    }>;
+    commandKey: z.ZodString;
+    fingerprint: z.ZodString;
+    actorId: z.ZodString;
+    createdAt: z.ZodString;
+    payload: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        product: z.ZodObject<{
+            id: z.ZodGUID;
+            type: z.ZodObject<{
+                key: z.ZodString;
+                version: z.ZodNumber;
+            }, z.core.$strict>;
+            slug: z.ZodOptional<z.ZodString>;
+            primarySkuId: z.ZodOptional<z.ZodGUID>;
+            dimensions: z.ZodArray<z.ZodString>;
+            sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+            documentRevision: z.ZodOptional<z.ZodObject<{
+                id: z.ZodGUID;
+                productId: z.ZodGUID;
+                revisionNo: z.ZodNumber;
+                schemaId: z.ZodString;
+                documentRef: z.ZodString;
+                sourceRef: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        skus: z.ZodArray<z.ZodObject<{
+            id: z.ZodGUID;
+            productId: z.ZodGUID;
+            code: z.ZodOptional<z.ZodString>;
+            options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"choice">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"quantity">;
+                value: z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>], "kind">>;
+            netContent: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                scheme: z.ZodString;
+                issuer: z.ZodString;
+                value: z.ZodString;
+                packagingLevel: z.ZodEnum<{
+                    unit: "unit";
+                    case: "case";
+                }>;
+                quantity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grossMass: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            priceRef: z.ZodOptional<z.ZodString>;
+            logisticsRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const catalogDraftPageSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        draftId: z.ZodGUID;
+        productId: z.ZodGUID;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            open: "open";
+            abandoned: "abandoned";
+        }>;
+        commandKey: z.ZodString;
+        fingerprint: z.ZodString;
+        actorId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodGUID>;
+}, z.core.$strict>;
+export declare const catalogDraftRefusalSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        conflict: "conflict";
+        validation_issue: "validation_issue";
+        unauthorized: "unauthorized";
+        dependency_unavailable: "dependency_unavailable";
+    }>;
+    reason: z.ZodString;
+    currentRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const catalogDraftApplyResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    outcome: z.ZodEnum<{
+        committed: "committed";
+        replayed: "replayed";
+    }>;
+    record: z.ZodObject<{
+        draftId: z.ZodGUID;
+        productId: z.ZodGUID;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            open: "open";
+            abandoned: "abandoned";
+        }>;
+        commandKey: z.ZodString;
+        fingerprint: z.ZodString;
+        actorId: z.ZodString;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            product: z.ZodObject<{
+                id: z.ZodGUID;
+                type: z.ZodObject<{
+                    key: z.ZodString;
+                    version: z.ZodNumber;
+                }, z.core.$strict>;
+                slug: z.ZodOptional<z.ZodString>;
+                primarySkuId: z.ZodOptional<z.ZodGUID>;
+                dimensions: z.ZodArray<z.ZodString>;
+                sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+                documentRevision: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodGUID;
+                    productId: z.ZodGUID;
+                    revisionNo: z.ZodNumber;
+                    schemaId: z.ZodString;
+                    documentRef: z.ZodString;
+                    sourceRef: z.ZodString;
+                    digest: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            skus: z.ZodArray<z.ZodObject<{
+                id: z.ZodGUID;
+                productId: z.ZodGUID;
+                code: z.ZodOptional<z.ZodString>;
+                options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"choice">;
+                    value: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"quantity">;
+                    value: z.ZodObject<{
+                        dimension: z.ZodEnum<{
+                            count: "count";
+                            mass: "mass";
+                            volume: "volume";
+                        }>;
+                        unscaled: z.ZodString;
+                        scale: z.ZodNumber;
+                        unit: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"boolean">;
+                    value: z.ZodBoolean;
+                }, z.core.$strict>], "kind">>;
+                netContent: z.ZodOptional<z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>>;
+                identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    scheme: z.ZodString;
+                    issuer: z.ZodString;
+                    value: z.ZodString;
+                    packagingLevel: z.ZodEnum<{
+                        unit: "unit";
+                        case: "case";
+                    }>;
+                    quantity: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>;
+                assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                grossMass: z.ZodOptional<z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>>;
+                priceRef: z.ZodOptional<z.ZodString>;
+                logisticsRef: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodEnum<{
+        conflict: "conflict";
+        validation_issue: "validation_issue";
+        unauthorized: "unauthorized";
+        dependency_unavailable: "dependency_unavailable";
+    }>;
+    reason: z.ZodString;
+    currentRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>]>;

package/dist/catalog/draftSchemas.js

@@ -0,0 +1,89 @@
+import { z } from "./validation.js";
+import { CATALOG_DRAFT_MAX_PAGE, canonicalCatalogDraftJson } from "./contracts/draft.js";
+export { CATALOG_DRAFT_MAX_BYTES, CATALOG_DRAFT_MAX_PAGE, canonicalCatalogDraftJson } from "./contracts/draft.js";
+import { catalogDocumentRevisionRefSchema } from "./foundationSchemas.js";
+import { catalogDimensionKeySchema, catalogNamespacedKeySchema, catalogOptionValueSchema, catalogProductTypeRefSchema, catalogQuantitySchema, } from "./productTypeSchemas.js";
+const id = z.guid().refine((value) => value === value.toLowerCase(), "UUID must be lowercase");
+const reference = z.string().min(1).max(240).refine((value) => value.trim() === value);
+const code = z.string().min(1).max(160).regex(/^[A-Za-z0-9._:-]+$/u);
+const revision = z.number().int().min(0).max(2_147_483_646);
+const persistedRevision = z.number().int().positive().max(2_147_483_647);
+const commandKey = reference;
+const jsonContent = z.unknown().refine((value) => value !== undefined, "content must be JSON");
+export const catalogDraftPayloadSchema = z.object({
+    schemaVersion: z.literal(1),
+    product: z.object({
+        id, type: catalogProductTypeRefSchema, slug: code.optional(), primarySkuId: id.optional(),
+        dimensions: z.array(catalogDimensionKeySchema).max(16),
+        sharedContent: jsonContent.optional(), documentRevision: catalogDocumentRevisionRefSchema.optional(),
+    }).strict(),
+    skus: z.array(z.object({
+        id, productId: id, code: code.optional(),
+        options: z.record(catalogDimensionKeySchema, catalogOptionValueSchema),
+        netContent: catalogQuantitySchema.optional(),
+        identifiers: z.array(z.object({
+            scheme: catalogNamespacedKeySchema, issuer: reference, value: z.string().min(1).max(128),
+            packagingLevel: z.enum(["unit", "case"]), quantity: z.number().int().min(1).max(2_147_483_647).optional(),
+        }).strict()).max(32).optional(),
+        assetRefs: z.array(reference).max(32).optional(), grossMass: catalogQuantitySchema.optional(),
+        priceRef: reference.optional(), logisticsRef: reference.optional(),
+    }).strict()).max(10_000),
+}).strict().superRefine((payload, context) => {
+    try {
+        canonicalCatalogDraftJson(payload);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "payload must be bounded safe JSON" });
+    }
+    if (payload.product.documentRevision && payload.product.documentRevision.productId !== payload.product.id) {
+        context.addIssue({ code: "custom", path: ["product", "documentRevision", "productId"], message: "document must belong to product" });
+    }
+    if (payload.product.primarySkuId && !payload.skus.some((sku) => sku.id === payload.product.primarySkuId)) {
+        context.addIssue({ code: "custom", path: ["product", "primarySkuId"], message: "primary must belong to product" });
+    }
+    payload.skus.forEach((sku, index) => {
+        if (sku.productId !== payload.product.id)
+            context.addIssue({ code: "custom", path: ["skus", index, "productId"], message: "SKU must belong to product" });
+    });
+});
+export const catalogDraftCommandSchema = z.object({
+    schemaVersion: z.literal(1), action: z.enum(["create", "revise", "abandon"]),
+    draftId: id, commandKey, expectedRevision: revision, payload: catalogDraftPayloadSchema.optional(),
+}).strict().superRefine((command, context) => {
+    if ((command.action === "abandon") === (command.payload !== undefined)) {
+        context.addIssue({ code: "custom", path: ["payload"], message: "payload is required only for create and revise" });
+    }
+    if ((command.action === "create") !== (command.expectedRevision === 0)) {
+        context.addIssue({ code: "custom", path: ["expectedRevision"], message: "create starts at revision zero; other commands require a persisted revision" });
+    }
+});
+export const catalogDraftGetQuerySchema = z.object({
+    draftId: id, revision: persistedRevision.optional(), commandKey: commandKey.optional(),
+}).strict().refine((query) => query.revision === undefined || query.commandKey === undefined, "selectors are mutually exclusive");
+export const catalogDraftListQuerySchema = z.object({
+    afterDraftId: id.optional(), limit: z.number().int().min(1).max(CATALOG_DRAFT_MAX_PAGE),
+}).strict();
+export const catalogDraftSummarySchema = z.object({
+    draftId: id, productId: id, revision: persistedRevision, status: z.enum(["open", "abandoned"]),
+    commandKey, fingerprint: z.string().regex(/^[a-f0-9]{64}$/u), actorId: reference,
+    createdAt: z.string().datetime({ offset: true }),
+}).strict();
+export const catalogDraftRecordSchema = catalogDraftSummarySchema.extend({ payload: catalogDraftPayloadSchema }).strict()
+    .refine((record) => record.productId === record.payload.product.id, "record product must own payload");
+export const catalogDraftPageSchema = z.object({
+    items: z.array(catalogDraftSummarySchema).max(CATALOG_DRAFT_MAX_PAGE), nextCursor: id.nullable(),
+}).strict().superRefine((page, context) => {
+    const ids = page.items.map((item) => item.draftId);
+    if (ids.some((value, index) => index > 0 && value <= ids[index - 1])
+        || (page.nextCursor !== null && page.nextCursor !== ids[ids.length - 1])) {
+        context.addIssue({ code: "custom", message: "page must have ordered unique heads and a matching cursor" });
+    }
+});
+export const catalogDraftRefusalSchema = z.object({
+    outcome: z.enum(["conflict", "validation_issue", "unauthorized", "dependency_unavailable"]),
+    reason: z.string().min(1).max(160).regex(/^[a-z][a-z0-9_]*$/u), currentRevision: z.number().int().min(0).max(2_147_483_647).optional(),
+}).strict();
+export const catalogDraftApplyResultSchema = z.union([
+    z.object({ outcome: z.enum(["committed", "replayed"]), record: catalogDraftRecordSchema }).strict(),
+    catalogDraftRefusalSchema,
+]);

package/dist/catalog/draftValidation.d.ts

@@ -0,0 +1,21 @@
+import type { CatalogDraftPayload } from "./draftSchemas.js";
+import { type CatalogDraftIssue, type CatalogProductTypeRegistry } from "./productTypeSchemas.js";
+export interface CatalogDraftReadiness {
+    publication: {
+        status: "incomplete" | "not_assessed";
+        issues: CatalogDraftIssue[];
+    };
+    commercial: {
+        status: "inactive";
+        issues: CatalogDraftIssue[];
+    };
+}
+export type CatalogDraftValidation = {
+    valid: false;
+    issues: CatalogDraftIssue[];
+} | {
+    valid: true;
+    readiness: CatalogDraftReadiness;
+};
+/** Supplied facts must be true; absent publish-time facts remain draft readiness issues. */
+export declare function validateCatalogDraft(payload: CatalogDraftPayload, registry: CatalogProductTypeRegistry): CatalogDraftValidation;