@pascal-app/core 1.0.1 → 1.0.4

package/dist/schema/nodes/window.js

@@ -1,19 +1,10 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
+import { GeometryScriptSource } from '../geometry-source.js';
 import { MaterialSchema } from '../material.js';
-export const WindowType = z.enum([
-    'fixed',
-    'sliding',
-    'casement',
-    'awning',
-    'hopper',
-    'single-hung',
-    'double-hung',
-    'bay',
-    'bow',
-    'louvered',
-]);
+import { WindowType } from './opening-types.js';
+export { WindowType } from './opening-types.js';
 export const WindowConstructionType = z.enum(['framed', 'masonry']);
 export const WindowDimensionReference = z.enum([
     'nominal',
@@ -26,12 +17,19 @@ export const WindowNode = BaseNode.extend({
     type: nodeType('window'),
     material: MaterialSchema.optional(),
     // Per-slot material overrides on the unified slot model. Keys: `frame`,
-    // `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`). Absent =
-    // the frame/glass default. Mirrors `ShelfNode.slots`.
+    // `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`) or a plain
+    // `#rrggbb` colour. Absent = the frame/glass default. Mirrors `ShelfNode.slots`.
     slots: z.record(z.string(), z.string()).optional(),
+    /**
+     * A three.js script the window is built from instead of its parametric frame, as on an item:
+     * width and height are the compiled bounds and the wall cuts the script's `cutout` mesh.
+     */
+    source: GeometryScriptSource.optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     side: z.enum(['front', 'back']).optional(),
+    verticalAnchor: z.enum(['wall', 'floor']).optional(),
+    floorThresholdVersion: z.union([z.literal(0), z.literal(1)]).default(1),
     // Wall reference
     wallId: z.string().optional(),
     // Alternative host: a dormer's generated wall face. When set, `position`

package/dist/schema/nodes/zone.d.ts

@@ -13,15 +13,83 @@ export declare const ZoneNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"zone">>;
     name: z.ZodString;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;
     boundaryWallIds: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>>>;
+    boundarySeparatorIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hostZoneId: z.ZodOptional<z.ZodString>;
+    seed: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    floor: z.ZodOptional<z.ZodObject<{
+        elevation: z.ZodOptional<z.ZodNumber>;
+        support: z.ZodOptional<z.ZodLiteral<"open">>;
+        footprint: z.ZodOptional<z.ZodString>;
+        thickness: z.ZodOptional<z.ZodNumber>;
+        sourceSlabId: z.ZodOptional<z.ZodTemplateLiteral<`slab_${string}`>>;
+        finish: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        regions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    ceiling: z.ZodOptional<z.ZodObject<{
+        regions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    floorStepFinish: z.ZodOptional<z.ZodString>;
+    floorStepOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        step: z.ZodOptional<z.ZodNumber>;
+        finish: z.ZodString;
+    }, z.core.$strip>>>;
+    floorEdgeFinish: z.ZodOptional<z.ZodString>;
+    wallMaterial: z.ZodOptional<z.ZodString>;
+    wallOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        wallId: z.ZodString;
+        face: z.ZodEnum<{
+            a: "a";
+            b: "b";
+        }>;
+        finish: z.ZodString;
+    }, z.core.$strip>>>;
+    hasFloor: z.ZodOptional<z.ZodLiteral<false>>;
+    hasCeiling: z.ZodOptional<z.ZodLiteral<false>>;
     spaceRole: z.ZodDefault<z.ZodEnum<{
-        generic: "generic";
         room: "room";
+        generic: "generic";
     }>>;
     roomNumber: z.ZodDefault<z.ZodString>;
     enclosureStatus: z.ZodDefault<z.ZodEnum<{

package/dist/schema/nodes/zone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0FpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/zone.js

@@ -1,6 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
+import { SurfacePaintRegion } from './surface-paint-region.js';
 export const ZoneNode = BaseNode.extend({
     id: objectId('zone'),
     type: nodeType('zone'),
@@ -9,8 +10,51 @@ export const ZoneNode = BaseNode.extend({
     polygon: z.array(z.tuple([z.number(), z.number()])),
     // Procedural room zones retain the walls that prove their enclosure. The
     // stored polygon remains a fallback for missing or temporarily open walls.
+    holes: z.array(z.array(z.tuple([z.number(), z.number()]))).default([]),
     autoFromWalls: z.boolean().default(false),
     boundaryWallIds: z.array(objectId('wall')).default([]),
+    boundarySeparatorIds: z.array(z.string()).default([]),
+    hostZoneId: z.string().optional(),
+    seed: z.tuple([z.number(), z.number()]).optional(),
+    floor: z
+        .object({
+        elevation: z.number().optional(),
+        support: z.literal('open').optional(),
+        footprint: z.string().min(1).optional(),
+        thickness: z.number().min(0.02).optional(),
+        sourceSlabId: z.templateLiteral(['slab_', z.string()]).optional(),
+        finish: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+        regions: z.array(SurfacePaintRegion).optional(),
+    })
+        .optional(),
+    // Painted parts of the room's ceiling. The automatic ceilings are rebuilt
+    // from the room, so what the user painted on them lives here.
+    ceiling: z
+        .object({
+        regions: z.array(SurfacePaintRegion).optional(),
+    })
+        .optional(),
+    floorStepFinish: z.string().optional(),
+    // Per-doorway step paint over `floorStepFinish`, keyed by the door the step
+    // sits under or the lower room it looks at (see `lib/floor-step-finish`).
+    floorStepOverrides: z
+        .array(z.object({
+        key: z.string(),
+        step: z.number().int().min(0).optional(),
+        finish: z.string(),
+    }))
+        .optional(),
+    floorEdgeFinish: z.string().optional(),
+    wallMaterial: z.string().optional(),
+    wallOverrides: z
+        .array(z.object({
+        wallId: z.string(),
+        face: z.enum(['a', 'b']),
+        finish: z.string(),
+    }))
+        .optional(),
+    hasFloor: z.literal(false).optional(),
+    hasCeiling: z.literal(false).optional(),
     // Generic zones remain available for sites and analysis. Architectural
     // room documentation is opt-in so legacy zone behavior is unchanged.
     spaceRole: z.enum(['generic', 'room']).default('generic'),
@@ -36,6 +80,8 @@ export const ZoneNode = BaseNode.extend({
   - boundaryWallIds: wall ids that prove the procedural enclosure
   - spaceRole: generic site/analysis zone or architectural room
   - roomNumber/finishes/ceilingHeight/occupancy: construction-document room metadata
+  - floor.regions / ceiling.regions: painted parts of the room's floor and ceiling ([x, z] polygons, later wins)
+  - floorStepFinish: finish of the room's steps; floorStepOverrides: per-doorway step finishes keyed by door id (or the lower room id), optional step index
   - enclosureStatus: auto-detected, explicitly enclosed, or open
   - clearDimensionPolicy: optional room clear-dimension datum preference
   - color: hex color for visual styling

package/dist/schema/provenance.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+/**
+ * Typed source identity of a node (owner decision D5): which source elements
+ * it reproduces, and which nodes it was derived from by an edit.
+ *
+ * The field is `provenance`, not `source`: a hosted third-party plugin already
+ * declares its own top-level `source` (`articraft:asset`), and `.extend()`
+ * would silently replace the base field for that kind.
+ *
+ * Caps are fixed and never enforced by truncation. A node over a cap fails
+ * its schema, so every validated writer (store, hosted save, collaboration,
+ * MCP) refuses it with an issue at the capped path, while load keeps a stored
+ * node verbatim. A writer with more ids than fit must refuse, or keep the
+ * extra ids off the node (sub-record `src`, the import artifact's alias table).
+ *
+ * Length caps are UTF-8 bytes (F8): every string is printable ASCII, one byte
+ * per character, and an importer percent-encodes anything else, which keeps
+ * the id exactly recoverable. A byte-counting refinement would not survive the
+ * JSON Schema snapshot hosted plugins are validated by. A maximal value,
+ * JSON escapes included, serialises to under 24 KiB, the F8 field cap. Bulk
+ * writers chunk their operations by encoded bytes.
+ */
+/** Refs per node. The /next house's largest node carries 18 source ids. */
+export declare const PROVENANCE_MAX_REFS = 32;
+/** Node ids in one lineage record (the pieces of a merge). */
+export declare const PROVENANCE_MAX_LINEAGE_IDS = 32;
+/** A namespace: `al` (a SketchUp source at a config hash), `ifc:<file>`, `cap:<capture>`. */
+export declare const PROVENANCE_MAX_NAMESPACE_BYTES = 48;
+/** A source id, stored verbatim (never slugged). The house's longest is 72. */
+export declare const PROVENANCE_MAX_ID_BYTES = 160;
+/** A node id, as the collaboration protocol bounds it. */
+export declare const PROVENANCE_MAX_NODE_ID_BYTES = 128;
+/**
+ * How a ref claims its source element:
+ * - `primary`: this node reproduces the element 1:1 (the default when absent);
+ * - `piece`: one of several declared pieces across sibling nodes, scored on their union;
+ * - `absorbed`: folded into this node without an address of its own (traceable, never exact);
+ * - `alias`: a retired id that resolves to this node;
+ * - `derived`: a copy or user variant; it never claims the element.
+ */
+export declare const ProvenanceRole: z.ZodEnum<{
+    primary: "primary";
+    piece: "piece";
+    absorbed: "absorbed";
+    alias: "alias";
+    derived: "derived";
+}>;
+export type ProvenanceRole = z.infer<typeof ProvenanceRole>;
+export declare const ProvenanceRef: z.ZodObject<{
+    ns: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    role: z.ZodOptional<z.ZodEnum<{
+        primary: "primary";
+        piece: "piece";
+        absorbed: "absorbed";
+        alias: "alias";
+        derived: "derived";
+    }>>;
+}, z.core.$strip>;
+export type ProvenanceRef = z.infer<typeof ProvenanceRef>;
+export declare const ProvenanceLineageOp: z.ZodEnum<{
+    import: "import";
+    split: "split";
+    merge: "merge";
+    duplicate: "duplicate";
+    convert: "convert";
+    promote: "promote";
+    "make-independent": "make-independent";
+    attach: "attach";
+}>;
+export type ProvenanceLineageOp = z.infer<typeof ProvenanceLineageOp>;
+/**
+ * The last edit that derived this node, and the node ids it came from. The ids
+ * are history: they are compared, never dereferenced, and may name nodes that
+ * no longer exist (the other walls of a merge).
+ */
+export declare const ProvenanceLineage: z.ZodObject<{
+    op: z.ZodEnum<{
+        import: "import";
+        split: "split";
+        merge: "merge";
+        duplicate: "duplicate";
+        convert: "convert";
+        promote: "promote";
+        "make-independent": "make-independent";
+        attach: "attach";
+    }>;
+    fromIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ProvenanceLineage = z.infer<typeof ProvenanceLineage>;
+export declare const Provenance: z.ZodObject<{
+    refs: z.ZodArray<z.ZodObject<{
+        ns: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        role: z.ZodOptional<z.ZodEnum<{
+            primary: "primary";
+            piece: "piece";
+            absorbed: "absorbed";
+            alias: "alias";
+            derived: "derived";
+        }>>;
+    }, z.core.$strip>>;
+    lineage: z.ZodOptional<z.ZodObject<{
+        op: z.ZodEnum<{
+            import: "import";
+            split: "split";
+            merge: "merge";
+            duplicate: "duplicate";
+            convert: "convert";
+            promote: "promote";
+            "make-independent": "make-independent";
+            attach: "attach";
+        }>;
+        fromIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Provenance = z.infer<typeof Provenance>;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/schema/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../src/schema/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,KAAK,CAAA;AACrC,8DAA8D;AAC9D,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAC5C,6FAA6F;AAC7F,eAAO,MAAM,8BAA8B,KAAK,CAAA;AAChD,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAC1C,0DAA0D;AAC1D,eAAO,MAAM,4BAA4B,MAAM,CAAA;AAY/C;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;EAA+D,CAAA;AAC1F,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,aAAa;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEzD,eAAO,MAAM,mBAAmB;;;;;;;;;EAS9B,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;iBAG5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/provenance.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+/**
+ * Typed source identity of a node (owner decision D5): which source elements
+ * it reproduces, and which nodes it was derived from by an edit.
+ *
+ * The field is `provenance`, not `source`: a hosted third-party plugin already
+ * declares its own top-level `source` (`articraft:asset`), and `.extend()`
+ * would silently replace the base field for that kind.
+ *
+ * Caps are fixed and never enforced by truncation. A node over a cap fails
+ * its schema, so every validated writer (store, hosted save, collaboration,
+ * MCP) refuses it with an issue at the capped path, while load keeps a stored
+ * node verbatim. A writer with more ids than fit must refuse, or keep the
+ * extra ids off the node (sub-record `src`, the import artifact's alias table).
+ *
+ * Length caps are UTF-8 bytes (F8): every string is printable ASCII, one byte
+ * per character, and an importer percent-encodes anything else, which keeps
+ * the id exactly recoverable. A byte-counting refinement would not survive the
+ * JSON Schema snapshot hosted plugins are validated by. A maximal value,
+ * JSON escapes included, serialises to under 24 KiB, the F8 field cap. Bulk
+ * writers chunk their operations by encoded bytes.
+ */
+/** Refs per node. The /next house's largest node carries 18 source ids. */
+export const PROVENANCE_MAX_REFS = 32;
+/** Node ids in one lineage record (the pieces of a merge). */
+export const PROVENANCE_MAX_LINEAGE_IDS = 32;
+/** A namespace: `al` (a SketchUp source at a config hash), `ifc:<file>`, `cap:<capture>`. */
+export const PROVENANCE_MAX_NAMESPACE_BYTES = 48;
+/** A source id, stored verbatim (never slugged). The house's longest is 72. */
+export const PROVENANCE_MAX_ID_BYTES = 160;
+/** A node id, as the collaboration protocol bounds it. */
+export const PROVENANCE_MAX_NODE_ID_BYTES = 128;
+const PRINTABLE_ASCII = /^[\x20-\x7E]*$/;
+/** A non-empty printable-ASCII string of at most `bytes` UTF-8 bytes. */
+const asciiString = (bytes) => z
+    .string()
+    .min(1)
+    .max(bytes)
+    .regex(PRINTABLE_ASCII, 'Printable ASCII only: percent-encode other characters.');
+/**
+ * How a ref claims its source element:
+ * - `primary`: this node reproduces the element 1:1 (the default when absent);
+ * - `piece`: one of several declared pieces across sibling nodes, scored on their union;
+ * - `absorbed`: folded into this node without an address of its own (traceable, never exact);
+ * - `alias`: a retired id that resolves to this node;
+ * - `derived`: a copy or user variant; it never claims the element.
+ */
+export const ProvenanceRole = z.enum(['primary', 'piece', 'absorbed', 'alias', 'derived']);
+export const ProvenanceRef = z.object({
+    ns: asciiString(PROVENANCE_MAX_NAMESPACE_BYTES).optional(),
+    id: asciiString(PROVENANCE_MAX_ID_BYTES),
+    role: ProvenanceRole.optional(),
+});
+export const ProvenanceLineageOp = z.enum([
+    'import',
+    'split',
+    'merge',
+    'duplicate',
+    'convert',
+    'promote',
+    'make-independent',
+    'attach',
+]);
+/**
+ * The last edit that derived this node, and the node ids it came from. The ids
+ * are history: they are compared, never dereferenced, and may name nodes that
+ * no longer exist (the other walls of a merge).
+ */
+export const ProvenanceLineage = z.object({
+    op: ProvenanceLineageOp,
+    fromIds: z.array(asciiString(PROVENANCE_MAX_NODE_ID_BYTES)).max(PROVENANCE_MAX_LINEAGE_IDS),
+});
+export const Provenance = z.object({
+    refs: z.array(ProvenanceRef).max(PROVENANCE_MAX_REFS),
+    lineage: ProvenanceLineage.optional(),
+});

package/dist/schema/source-ref.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/**
+ * One source reference as a string: `<ns>:<id>[::<sub>]`, the address form of a
+ * typed provenance ref `{ ns, id }` (plan item I-01, owner decision D5) plus an
+ * optional sub-part. Sub-records that carry provenance (an assembly layer's
+ * `src`) store it in this form.
+ *
+ * - `ns`: the source namespace, ≤ 48 bytes. It may carry its own qualifier
+ *   (`ifc:<file>`), so the id starts after the last single `:`.
+ * - `id`: the source id, verbatim, ≤ 160 bytes, without `:`.
+ * - `sub`: everything after the first `::`, ≤ 160 bytes.
+ * No part is empty. Like the typed ref (`ProvenanceRef`, whose byte caps these
+ * are), every character is printable ASCII, spaces included, one byte each;
+ * importers percent-encode anything else.
+ */
+export type ParsedSourceRef = {
+    ns: string;
+    id: string;
+    sub?: string;
+};
+export declare function parseSourceRef(value: string): ParsedSourceRef | null;
+export declare const SourceRefString: z.ZodString;
+//# sourceMappingURL=source-ref.d.ts.map

package/dist/schema/source-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-ref.d.ts","sourceRoot":"","sources":["../../src/schema/source-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAItE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAmBpE;AAED,eAAO,MAAM,eAAe,aAE1B,CAAA"}

package/dist/schema/source-ref.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { PROVENANCE_MAX_ID_BYTES, PROVENANCE_MAX_NAMESPACE_BYTES } from './provenance.js';
+const PRINTABLE_ASCII = /^[\x20-\x7E]*$/;
+export function parseSourceRef(value) {
+    if (!PRINTABLE_ASCII.test(value))
+        return null;
+    const subAt = value.indexOf('::');
+    const head = subAt < 0 ? value : value.slice(0, subAt);
+    const sub = subAt < 0 ? undefined : value.slice(subAt + 2);
+    const colon = head.lastIndexOf(':');
+    if (colon < 0)
+        return null;
+    const ns = head.slice(0, colon);
+    const id = head.slice(colon + 1);
+    if (ns.length > PROVENANCE_MAX_NAMESPACE_BYTES ||
+        ns.split(':').some((part) => part.length === 0)) {
+        return null;
+    }
+    if (id.length === 0 || id.length > PROVENANCE_MAX_ID_BYTES)
+        return null;
+    if (sub === undefined)
+        return { ns, id };
+    if (sub.length === 0 || sub.length > PROVENANCE_MAX_ID_BYTES)
+        return null;
+    return { ns, id, sub };
+}
+export const SourceRefString = z.string().refine((value) => parseSourceRef(value) !== null, {
+    message: 'Expected a source reference <ns>:<id>[::<sub>]',
+});