@openparser/lineage 1.0.2

package/dist/document.d.ts

@@ -0,0 +1,412 @@
+import { z } from 'zod';
+import { LineageValidationError } from './validate.js';
+/**
+ * Structural Zod schema for a `lineage@1` document (shape only).
+ * Use {@link LineageDocumentSchema} or {@link parseLineageDocument} for
+ * shape + strict graph validation.
+ */
+export declare const LineageDocumentShapeSchema: z.ZodObject<{
+    format: z.ZodLiteral<"lineage@1">;
+    id: z.ZodOptional<z.ZodString>;
+    profiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entities: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodEnum<{
+            value: "value";
+            artifact: "artifact";
+            evidence: "evidence";
+            decision: "decision";
+            collection: "collection";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+        path: z.ZodOptional<z.ZodString>;
+        schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        locator: z.ZodOptional<z.ZodObject<{
+            uri: z.ZodString;
+            mediaType: z.ZodOptional<z.ZodString>;
+            digest: z.ZodOptional<z.ZodObject<{
+                algorithm: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        selector: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            value: z.ZodJSONSchema;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        digest: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        confidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            score: z.ZodNumber;
+            scale: z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                reported: "reported";
+                derived: "derived";
+                assessed: "assessed";
+            }>;
+            scope: z.ZodString;
+            granularity: z.ZodOptional<z.ZodString>;
+            calibrated: z.ZodDefault<z.ZodBoolean>;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    agent: "agent";
+                    entity: "entity";
+                    activity: "activity";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>>;
+            method: z.ZodOptional<z.ZodString>;
+            sampleCount: z.ZodOptional<z.ZodNumber>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        approvals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            at: z.ZodString;
+            note: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        attributions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            role: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    activities: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            scheduled: "scheduled";
+            started: "started";
+            ended: "ended";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>>;
+        startedAt: z.ZodOptional<z.ZodISODateTime>;
+        endedAt: z.ZodOptional<z.ZodISODateTime>;
+        implementation: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            uri: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        associations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            role: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    derivations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        output: z.ZodString;
+        activity: z.ZodString;
+        inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            entity: z.ZodString;
+            role: z.ZodOptional<z.ZodString>;
+            effect: z.ZodDefault<z.ZodEnum<{
+                direct: "direct";
+                indirect: "indirect";
+            }>>;
+            confidence: z.ZodOptional<z.ZodObject<{
+                score: z.ZodNumber;
+                scale: z.ZodObject<{
+                    min: z.ZodNumber;
+                    max: z.ZodNumber;
+                }, z.core.$strict>;
+                kind: z.ZodEnum<{
+                    reported: "reported";
+                    derived: "derived";
+                    assessed: "assessed";
+                }>;
+                scope: z.ZodString;
+                granularity: z.ZodOptional<z.ZodString>;
+                calibrated: z.ZodDefault<z.ZodBoolean>;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        agent: "agent";
+                        entity: "entity";
+                        activity: "activity";
+                    }>;
+                    id: z.ZodString;
+                }, z.core.$strict>>>;
+                method: z.ZodOptional<z.ZodString>;
+                sampleCount: z.ZodOptional<z.ZodNumber>;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            }, z.core.$strict>>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        transformation: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            expression: z.ZodOptional<z.ZodString>;
+            masking: z.ZodOptional<z.ZodBoolean>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        confidence: z.ZodOptional<z.ZodObject<{
+            score: z.ZodNumber;
+            scale: z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                reported: "reported";
+                derived: "derived";
+                assessed: "assessed";
+            }>;
+            scope: z.ZodString;
+            granularity: z.ZodOptional<z.ZodString>;
+            calibrated: z.ZodDefault<z.ZodBoolean>;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    agent: "agent";
+                    entity: "entity";
+                    activity: "activity";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>>;
+            method: z.ZodOptional<z.ZodString>;
+            sampleCount: z.ZodOptional<z.ZodNumber>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            member_of: "member_of";
+            specialization_of: "specialization_of";
+            alternate_of: "alternate_of";
+        }>;
+        source: z.ZodString;
+        target: z.ZodString;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type LineageDocument = z.infer<typeof LineageDocumentShapeSchema>;
+/**
+ * Parse and strictly validate a lineage document (shape + graph invariants).
+ */
+export declare function parseLineageDocument(input: unknown): LineageDocument;
+/**
+ * Safe parse with Zod issues and/or graph validation errors.
+ */
+export declare function safeParseLineageDocument(input: unknown): {
+    success: true;
+    data: LineageDocument;
+} | {
+    success: false;
+    error: z.ZodError | LineageValidationError;
+};
+/**
+ * Zod schema that applies graph validation via `superRefine`. Prefer
+ * {@link parseLineageDocument} when you want thrown `LineageValidationError`
+ * with structured issue lists.
+ */
+export declare const LineageDocumentSchema: z.ZodObject<{
+    format: z.ZodLiteral<"lineage@1">;
+    id: z.ZodOptional<z.ZodString>;
+    profiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entities: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodEnum<{
+            value: "value";
+            artifact: "artifact";
+            evidence: "evidence";
+            decision: "decision";
+            collection: "collection";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+        path: z.ZodOptional<z.ZodString>;
+        schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        locator: z.ZodOptional<z.ZodObject<{
+            uri: z.ZodString;
+            mediaType: z.ZodOptional<z.ZodString>;
+            digest: z.ZodOptional<z.ZodObject<{
+                algorithm: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        selector: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            value: z.ZodJSONSchema;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        digest: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        confidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            score: z.ZodNumber;
+            scale: z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                reported: "reported";
+                derived: "derived";
+                assessed: "assessed";
+            }>;
+            scope: z.ZodString;
+            granularity: z.ZodOptional<z.ZodString>;
+            calibrated: z.ZodDefault<z.ZodBoolean>;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    agent: "agent";
+                    entity: "entity";
+                    activity: "activity";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>>;
+            method: z.ZodOptional<z.ZodString>;
+            sampleCount: z.ZodOptional<z.ZodNumber>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        approvals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            at: z.ZodString;
+            note: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        attributions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            role: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    activities: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            scheduled: "scheduled";
+            started: "started";
+            ended: "ended";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>>;
+        startedAt: z.ZodOptional<z.ZodISODateTime>;
+        endedAt: z.ZodOptional<z.ZodISODateTime>;
+        implementation: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            uri: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        associations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            role: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    derivations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        output: z.ZodString;
+        activity: z.ZodString;
+        inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            entity: z.ZodString;
+            role: z.ZodOptional<z.ZodString>;
+            effect: z.ZodDefault<z.ZodEnum<{
+                direct: "direct";
+                indirect: "indirect";
+            }>>;
+            confidence: z.ZodOptional<z.ZodObject<{
+                score: z.ZodNumber;
+                scale: z.ZodObject<{
+                    min: z.ZodNumber;
+                    max: z.ZodNumber;
+                }, z.core.$strict>;
+                kind: z.ZodEnum<{
+                    reported: "reported";
+                    derived: "derived";
+                    assessed: "assessed";
+                }>;
+                scope: z.ZodString;
+                granularity: z.ZodOptional<z.ZodString>;
+                calibrated: z.ZodDefault<z.ZodBoolean>;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        agent: "agent";
+                        entity: "entity";
+                        activity: "activity";
+                    }>;
+                    id: z.ZodString;
+                }, z.core.$strict>>>;
+                method: z.ZodOptional<z.ZodString>;
+                sampleCount: z.ZodOptional<z.ZodNumber>;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            }, z.core.$strict>>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>>;
+        transformation: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            expression: z.ZodOptional<z.ZodString>;
+            masking: z.ZodOptional<z.ZodBoolean>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        confidence: z.ZodOptional<z.ZodObject<{
+            score: z.ZodNumber;
+            scale: z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                reported: "reported";
+                derived: "derived";
+                assessed: "assessed";
+            }>;
+            scope: z.ZodString;
+            granularity: z.ZodOptional<z.ZodString>;
+            calibrated: z.ZodDefault<z.ZodBoolean>;
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    agent: "agent";
+                    entity: "entity";
+                    activity: "activity";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>>;
+            method: z.ZodOptional<z.ZodString>;
+            sampleCount: z.ZodOptional<z.ZodNumber>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        }, z.core.$strict>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            member_of: "member_of";
+            specialization_of: "specialization_of";
+            alternate_of: "alternate_of";
+        }>;
+        source: z.ZodString;
+        target: z.ZodString;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+//# sourceMappingURL=document.d.ts.map

package/dist/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAAE,sBAAsB,EAAwB,MAAM,YAAY,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAe5B,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEzE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAIpE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GAEZ;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GACxC;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,sBAAsB,CAAA;CAAE,CAcjE;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYhC,CAAC"}

package/dist/entity.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+/** How an agent relates to an entity (PROV wasAttributedTo). */
+export declare const AttributionSchema: z.ZodObject<{
+    agent: z.ZodString;
+    role: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type Attribution = z.infer<typeof AttributionSchema>;
+/**
+ * Content-addressing digest for artifacts or values when a cryptographic
+ * fingerprint is available.
+ */
+export declare const DigestSchema: z.ZodObject<{
+    algorithm: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strict>;
+export type Digest = z.infer<typeof DigestSchema>;
+/**
+ * External location of an artifact (URI, media type, optional integrity).
+ */
+export declare const LocatorSchema: z.ZodObject<{
+    uri: z.ZodString;
+    mediaType: z.ZodOptional<z.ZodString>;
+    digest: z.ZodOptional<z.ZodObject<{
+        algorithm: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type Locator = z.infer<typeof LocatorSchema>;
+/**
+ * Sub-resource selector within a located artifact (JSON Pointer, XPath,
+ * page/region, byte range, etc.). `type` is open for profiles.
+ */
+export declare const SelectorSchema: z.ZodObject<{
+    type: z.ZodString;
+    value: z.ZodJSONSchema;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type Selector = z.infer<typeof SelectorSchema>;
+export declare const ENTITY_KINDS: readonly ["value", "artifact", "evidence", "decision", "collection"];
+export declare const EntityKindSchema: z.ZodEnum<{
+    value: "value";
+    artifact: "artifact";
+    evidence: "evidence";
+    decision: "decision";
+    collection: "collection";
+}>;
+export type EntityKind = z.infer<typeof EntityKindSchema>;
+/**
+ * A node in the derivation DAG: data value, file/blob, supporting evidence,
+ * a decision outcome, or a collection of other entities.
+ *
+ * Map keys in `LineageDocument.entities` are the authoritative entity ids.
+ */
+export declare const EntitySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        value: "value";
+        artifact: "artifact";
+        evidence: "evidence";
+        decision: "decision";
+        collection: "collection";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodJSONSchema>;
+    path: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    locator: z.ZodOptional<z.ZodObject<{
+        uri: z.ZodString;
+        mediaType: z.ZodOptional<z.ZodString>;
+        digest: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>;
+    selector: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodJSONSchema;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>;
+    digest: z.ZodOptional<z.ZodObject<{
+        algorithm: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+    confidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        score: z.ZodNumber;
+        scale: z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, z.core.$strict>;
+        kind: z.ZodEnum<{
+            reported: "reported";
+            derived: "derived";
+            assessed: "assessed";
+        }>;
+        scope: z.ZodString;
+        granularity: z.ZodOptional<z.ZodString>;
+        calibrated: z.ZodDefault<z.ZodBoolean>;
+        sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                agent: "agent";
+                entity: "entity";
+                activity: "activity";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>>;
+        method: z.ZodOptional<z.ZodString>;
+        sampleCount: z.ZodOptional<z.ZodNumber>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    approvals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agent: z.ZodString;
+        at: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    attributions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agent: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type Entity = z.infer<typeof EntitySchema>;
+//# sourceMappingURL=entity.d.ts.map

package/dist/entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../src/entity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;kBAMnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,YAAY;;;kBAKd,CAAC;AACZ,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;kBAOf,CAAC;AACZ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;kBAMhB,CAAC;AACZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,YAAY,sEAAuE,CAAC;AACjG,eAAO,MAAM,gBAAgB;;;;;;EAAuB,CAAC;AACrD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsBd,CAAC;AACZ,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/fields.d.ts

@@ -0,0 +1,76 @@
+import type { JsonValue } from './common.js';
+import type { ConfidenceAssertion, ConfidenceKind } from './confidence.js';
+import type { LineageDocument } from './document.js';
+import type { Entity } from './entity.js';
+/** How a field's confidence came about, or that none was asserted at all. */
+export type ConfidenceOrigin = ConfidenceKind | 'not_reported';
+export type LineageField = {
+    id: string;
+    pointer: string;
+    /**
+     * Display-only dotted rendering of `pointer`. Lossy: a property whose name
+     * contains a dot is indistinguishable from nesting. Use `pointer` as the key.
+     */
+    dottedPath: string;
+    value: JsonValue | undefined;
+    confidence: ConfidenceAssertion | undefined;
+    confidenceOrigin: ConfidenceOrigin;
+    entity: Entity;
+};
+export type LineageFieldTrace = {
+    field: LineageField;
+    evidence: Array<{
+        id: string;
+        entity: Entity;
+    }>;
+    activities: string[];
+};
+/**
+ * RFC 6901 pointer to dotted display path, unescaping `~1` and `~0`.
+ *
+ * Display only. A property whose name contains a dot is indistinguishable from
+ * nesting, so never use the result as a key.
+ */
+export declare function dottedPathFromPointer(pointer: string): string;
+/**
+ * Dotted display path back to an RFC 6901 pointer, escaping `~` and `/`.
+ *
+ * Only sound for paths `dottedPathFromPointer` could have produced: a property
+ * name containing a dot round-trips as nesting. Prefer carrying the pointer.
+ */
+export declare function pointerFromDottedPath(dottedPath: string): string;
+/**
+ * The entity holding a field's current value at `pointer`.
+ *
+ * Precedence is explicit and does not use `Object.entries` insertion order:
+ * 1. An entity at that path listed in `doc.outputs` — after review, `outputs`
+ *    is the current field set (plus a root snapshot / completion decision,
+ *    which do not share field paths). If several outputs match, the earliest
+ *    in `doc.outputs` wins.
+ * 2. Otherwise a `kind: 'decision'` entity at that path (the producer-settled
+ *    value on documents that never went through review). If several decisions
+ *    match, the lexicographically smallest id wins.
+ * 3. Otherwise the lexicographically smallest id among remaining matches.
+ *
+ * `path` is the only field locator, so this is the single supported way to go
+ * from a pointer to an entity id — ids themselves are not a stable contract.
+ */
+export declare function fieldEntityByPointer(doc: LineageDocument, pointer: string): {
+    id: string;
+    entity: Entity;
+} | undefined;
+/** Output field entities as fields, in `doc.outputs` order.
+ *
+ * Whole-document snapshots (`path === ''`) and other pathless outputs are
+ * omitted — they are the whole result (or a run-level decision), not a field.
+ */
+export declare function fields(doc: LineageDocument): LineageField[];
+/**
+ * Trace a field by JSON Pointer, including upstream evidence and activities.
+ *
+ * Whether that evidence is *sufficient* is a question for whoever produced the
+ * document, since it turns on their own attributes; see the OpenParser profile
+ * for one answer.
+ */
+export declare function fieldTrace(doc: LineageDocument, pointer: string): LineageFieldTrace | undefined;
+//# sourceMappingURL=fields.d.ts.map

package/dist/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../src/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGvC,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,cAAc,CAAC;AAE/D,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC;IAC7B,UAAU,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAC5C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChD,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAcF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO7D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,MAAM,GACd;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAe5C;AAgBD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,YAAY,EAAE,CAS3D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAmB/F"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Public `@openparser/lineage` surface for `lineage@1` complete data-derivation DAGs.
+ *
+ * Provider- and domain-agnostic provenance documents grounded in W3C PROV-DM
+ * semantics with ergonomic JSON. Root export only — no subpath exports.
+ */
+export { ACTIVITY_STATUSES, ActivitySchema, ActivityStatusSchema, AgentSchema, AssociationSchema, ImplementationSchema, type Activity, type ActivityStatus, type Agent, type Association, type Implementation, } from './activity.js';
+export { ApprovalAssertionSchema, type ApprovalAssertion } from './approval.js';
+export { LineageBuilder } from './builder.js';
+export { AttributesSchema, JsonPointerSchema, JsonValueSchema, LINEAGE_FORMAT, LineageFormatSchema, LineageIdSchema, TimestampSchema, jsonValuesEqual, type Attributes, type JsonPointer, type JsonValue, type LineageFormat, type LineageId, type Timestamp, } from './common.js';
+export { CONFIDENCE_KINDS, ConfidenceAssertionSchema, ConfidenceKindSchema, ConfidenceScaleSchema, ConfidenceSourceSchema, type ConfidenceAssertion, type ConfidenceKind, type ConfidenceScale, type ConfidenceSource, } from './confidence.js';
+export { DERIVATION_EFFECTS, DerivationEffectSchema, DerivationInputSchema, DerivationSchema, MAX_DERIVATION_INPUTS, TransformationSchema, derivationId, type Derivation, type DerivationEffect, type DerivationInput, type Transformation, } from './derivation.js';
+export { LineageDocumentSchema, LineageDocumentShapeSchema, parseLineageDocument, safeParseLineageDocument, type LineageDocument, } from './document.js';
+export { AttributionSchema, DigestSchema, ENTITY_KINDS, EntityKindSchema, EntitySchema, LocatorSchema, SelectorSchema, type Attribution, type Digest, type Entity, type EntityKind, type Locator, type Selector, } from './entity.js';
+export { LINEAGE_PROV_NAMESPACE, lineageIdToProvQualifiedName, toProvJson, type ProvJsonDocument, } from './prov.js';
+export { RELATION_TYPES, RelationSchema, RelationTypeSchema, type Relation, type RelationType, } from './relation.js';
+export { dottedPathFromPointer, fieldEntityByPointer, fieldTrace, fields, pointerFromDottedPath, type ConfidenceOrigin, type LineageField, type LineageFieldTrace, } from './fields.js';
+export { activityLabel } from './labels.js';
+export { entityAncestors, entityDescendants, topologicalEntityOrder } from './traverse.js';
+export { LineageValidationError, validateLineageGraph } from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,WAAW,EACX,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,KAAK,EACV,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE7E,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,eAAe,EACf,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,YAAY,EACZ,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,oBAAoB,EACpB,wBAAwB,EACxB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,KAAK,QAAQ,GACd,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,UAAU,EACV,KAAK,gBAAgB,GACtB,MAAM,QAAQ,CAAC;AAEhB,OAAO,EACL,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,KAAK,QAAQ,EACb,KAAK,YAAY,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,UAAU,EACV,MAAM,EACN,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,iBAAiB,GACvB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAExF,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC"}