@openparser/lineage 1.0.2

package/dist/profile/labels.d.ts

@@ -0,0 +1,10 @@
+import type { Activity } from '../activity.js';
+/**
+ * Display label for an OpenParser activity: an explicit `name` when a producer
+ * set one, otherwise a label for known types, otherwise the raw type.
+ *
+ * `type` is an open string, so unknown types render as themselves rather than
+ * being hidden behind a placeholder.
+ */
+export declare function activityLabel(activity: Activity): string;
+//# sourceMappingURL=labels.d.ts.map

package/dist/profile/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/profile/labels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAkB5C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAExD"}

package/dist/profile/recognition.d.ts

@@ -0,0 +1,70 @@
+/**
+ * How a value's recognition score is derived from the OCR words behind it.
+ *
+ * This is a profile rule, not part of `lineage@1`: the protocol says a score has
+ * a scale, a scope, and a named method, and stays silent on what any particular
+ * method computes. It ships beside the protocol because a producer and a consumer
+ * that disagree here disagree about what a number means. A region cited by two
+ * fields is read once but quoted differently by each, so scoring the region and
+ * scoring a value are different questions — and answering the second with the
+ * first is how a crisply scanned number ends up wearing its neighbor's bad
+ * handwriting.
+ */
+/** An OCR token with its recognition score, and whether a value was read from it. */
+export type ScoredWord = {
+    id?: string;
+    text: string;
+    confidence: number;
+    cited?: boolean;
+};
+export declare const CITED_RECOGNITION_METHOD = "cited_minimum_context_downblend";
+/** Scoring a whole region, because no word within it could be narrowed to. */
+export declare const REGION_RECOGNITION_METHOD = "region_word_minimum";
+/** How far the surrounding text may pull a cited score down. */
+export declare const CONTEXT_BLEND_WEIGHT = 0.15;
+/**
+ * Blend a cited-word minimum with the surrounding context: weaker context may
+ * only pull the score down, and never below what the blend allows. A noisy
+ * neighborhood is evidence that a value might be misread, not a verdict that it
+ * was.
+ */
+export declare function downwardBlendCitedMinimum(citedMin: number, contextMean: number | undefined): number;
+export type CitedWordAggregate = {
+    score: number;
+    minimum: number;
+    maximum: number;
+    sampleCount: number;
+    method: typeof CITED_RECOGNITION_METHOD | typeof REGION_RECOGNITION_METHOD;
+    contextMean?: number;
+    contextSampleCount?: number;
+};
+/**
+ * Score one value from the words it was read from, discounted by the words
+ * around it. With nothing marked cited there is nothing to narrow to, so every
+ * word counts, the result is the region's own weakest token, and `method` says
+ * so — a score over the whole region must not claim to have narrowed to a value.
+ */
+export declare function aggregateCitedWordConfidences(words: readonly ScoredWord[]): CitedWordAggregate | undefined;
+/** First candidate found in the text wins; pass candidates in priority order. */
+export declare function citedSpanInText(regionText: string, candidates: ReadonlyArray<string | undefined>): {
+    start: number;
+    end: number;
+};
+/**
+ * Mark the words a value was read from within a region.
+ *
+ * `extractedText` is what the extraction produced, which is always text present
+ * in the document: for a value returned as-is it is the value itself, and for one
+ * the model went on to rewrite — `2024-05-30` from `MAY 30, 2024` — it is the text
+ * that was actually read. Searching for the value instead would find nothing in
+ * the second case. `lineageWordTexts`/`lineageWordIds` name words a lineage
+ * document already attributes to the value, used when no span matches.
+ */
+export declare function annotateWordsWithCitation<T extends ScoredWord>(regionText: string, words: readonly T[], options?: {
+    extractedText?: string;
+    lineageWordTexts?: ReadonlySet<string>;
+    lineageWordIds?: ReadonlySet<string>;
+}): Array<T & {
+    cited: boolean;
+}>;
+//# sourceMappingURL=recognition.d.ts.map

package/dist/profile/recognition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognition.d.ts","sourceRoot":"","sources":["../../src/profile/recognition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,qFAAqF;AACrF,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,wBAAwB,oCAAoC,CAAC;AAE1E,8EAA8E;AAC9E,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,CAIR;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,wBAAwB,GAAG,OAAO,yBAAyB,CAAC;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,UAAU,EAAE,GAC3B,kBAAkB,GAAG,SAAS,CAoBhC;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,GAC5C;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAUhC;AAkBD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,UAAU,EAC5D,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,OAAO,CAAC,EAAE;IACR,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,cAAc,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACtC,GACA,KAAK,CAAC,CAAC,GAAG;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAc/B"}

package/dist/profile/transform-validation.d.ts

@@ -0,0 +1,250 @@
+import { z } from 'zod';
+export declare const TRANSFORM_VERIFICATION_DOCS = "https://docs.openparser.dev/lineage/openparser/transform-verification";
+export declare const TRANSFORM_PROOF_ATTRIBUTE = "openparser:transformProof";
+export declare const MAX_TRANSFORM_PROOF_BYTES = 2048;
+/** Admission budget so a newly accepted policy can always serialize inside a 2 KiB proof. */
+export declare const MAX_TRANSFORM_INTENT_PARAMETER_BYTES = 1024;
+export declare const TRANSFORM_DOCS_ANCHORS: readonly ["date-time-format", "numeric-format", "quantity-magnitude", "unit-conversion", "currency-code", "boolean-alias", "text-normalization", "enum-alias"];
+export type TransformDocsAnchor = (typeof TRANSFORM_DOCS_ANCHORS)[number];
+export declare const TransformProofClassSchema: z.ZodEnum<{
+    safe_equivalence: "safe_equivalence";
+    exact_conversion: "exact_conversion";
+    policy_application: "policy_application";
+}>;
+export type TransformProofClass = z.infer<typeof TransformProofClassSchema>;
+export type DateTimeKind = 'date' | 'date-time' | 'time';
+export declare function dateTimeFormatIssue(kind: DateTimeKind, sourceFormats: string[], targetFormat: string): string | undefined;
+/**
+ * Built-in Luxon source formats for format-only JSON Schema `date` / `date-time` /
+ * `time` intent. Versioned independently of `openparser.transform.date-time-format.v1`
+ * so accepted sources can grow without rewriting already-emitted proofs.
+ *
+ * v1 selection is conservative and not demo-specific:
+ * - ISO 8601 calendar date and the matching offset-bearing ISO date-time/time forms
+ * - Unambiguous year-first numeric calendar dates
+ * - Explicit English civil date families (day-first and US month-first, full or
+ *   abbreviated month names, and "N day of Month Year")
+ *
+ * Locale-ambiguous numeric day/month orders (`MM/dd/yyyy`, `dd/MM/yyyy`, …),
+ * two-digit years, weekday-prefixed forms, and natural-language parsers are
+ * omitted. A claim `source_format` may only prioritize a catalog member; it
+ * cannot add omitted forms or shrink the candidate set.
+ */
+export declare const DATE_SOURCE_CATALOG_ID: "openparser.transform.date-source-catalog";
+export declare const DATE_SOURCE_CATALOG_VERSION: 1;
+export declare const FORMAT_ONLY_DATE_TARGETS: {
+    readonly date: "yyyy-MM-dd";
+    readonly 'date-time': "yyyy-MM-dd'T'HH:mm:ssZZ";
+    readonly time: "HH:mm:ssZZ";
+};
+export declare const DATE_SOURCE_CATALOG_V1: Record<DateTimeKind, readonly string[]>;
+export declare function trustedDateSourceFormats(kind: DateTimeKind, targetFormat?: string): string[];
+export declare function formatOnlyDateTimeParameters(kind: DateTimeKind): {
+    kind: DateTimeKind;
+    sourceFormats: string[];
+    targetFormat: "yyyy-MM-dd" | "yyyy-MM-dd'T'HH:mm:ssZZ" | "HH:mm:ssZZ";
+    locale: string;
+    zonePolicy: "civil" | "preserve";
+    sourceCatalog: {
+        id: "openparser.transform.date-source-catalog";
+        version: 1;
+    };
+};
+export declare const TransformIntentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"date_time_format">;
+    parameters: z.ZodObject<{
+        kind: z.ZodEnum<{
+            date: "date";
+            time: "time";
+            "date-time": "date-time";
+        }>;
+        sourceFormats: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        targetFormat: z.ZodString;
+        locale: z.ZodDefault<z.ZodString>;
+        zonePolicy: z.ZodDefault<z.ZodEnum<{
+            civil: "civil";
+            preserve: "preserve";
+            utc: "utc";
+            named: "named";
+        }>>;
+        zone: z.ZodOptional<z.ZodString>;
+        sourceCatalog: z.ZodOptional<z.ZodObject<{
+            id: z.ZodLiteral<"openparser.transform.date-source-catalog">;
+            version: z.ZodLiteral<1>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"numeric_format">;
+    parameters: z.ZodObject<{
+        decimalSeparator: z.ZodDefault<z.ZodEnum<{
+            ",": ",";
+            ".": ".";
+        }>>;
+        groupingSeparator: z.ZodOptional<z.ZodEnum<{
+            ",": ",";
+            ".": ".";
+            " ": " ";
+            "\u00A0": " ";
+        }>>;
+        prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        suffixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        accountingParentheses: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"quantity_magnitude">;
+    parameters: z.ZodObject<{
+        allowedUnits: z.ZodRecord<z.ZodString, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;
+        targetUnit: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"unit_conversion">;
+    parameters: z.ZodObject<{
+        sourceUnits: z.ZodArray<z.ZodString>;
+        targetUnit: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"currency_code">;
+    parameters: z.ZodObject<{
+        acceptedCodes: z.ZodArray<z.ZodString>;
+        aliases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>>;
+        symbolMap: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"boolean_alias">;
+    parameters: z.ZodObject<{
+        aliases: z.ZodRecord<z.ZodString, z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>>;
+        caseSensitive: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"text_normalization">;
+    parameters: z.ZodObject<{
+        operations: z.ZodArray<z.ZodEnum<{
+            trim: "trim";
+            lowercase: "lowercase";
+            uppercase: "uppercase";
+            collapse_whitespace: "collapse_whitespace";
+            nfkc: "nfkc";
+        }>>;
+        locale: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"enum_alias">;
+    parameters: z.ZodObject<{
+        aliases: z.ZodRecord<z.ZodString, z.ZodType<string | number, unknown, z.core.$ZodTypeInternals<string | number, unknown>>>;
+        caseSensitive: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "operation">;
+export type TransformIntent = z.infer<typeof TransformIntentSchema>;
+export type TransformOperation = TransformIntent['operation'];
+export declare const TRANSFORM_OPERATIONS: readonly ["date_time_format", "numeric_format", "quantity_magnitude", "unit_conversion", "currency_code", "boolean_alias", "text_normalization", "enum_alias"];
+export declare const TransformClaimSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        "": "";
+        date_time_format: "date_time_format";
+        numeric_format: "numeric_format";
+        quantity_magnitude: "quantity_magnitude";
+        unit_conversion: "unit_conversion";
+        currency_code: "currency_code";
+        boolean_alias: "boolean_alias";
+        text_normalization: "text_normalization";
+        enum_alias: "enum_alias";
+    }>;
+    parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    reason: z.ZodString;
+    confidence: z.ZodEnum<{
+        "": "";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+}, z.core.$strict>;
+export type TransformClaim = z.infer<typeof TransformClaimSchema>;
+export declare const TRANSFORM_PROOF_OPERAND_KEYS: readonly ["bounded", "canonical", "magnitude", "mappedValue", "matchedSourceFormat", "output", "outputCode", "outputDecimal", "outputHash", "policyHash", "resolvedCode", "sourceDecimal", "sourceHash", "sourceMagnitude", "sourceUnit", "targetMagnitude", "targetUnit"];
+export declare const TransformProofHashSchema: z.ZodObject<{
+    algorithm: z.ZodLiteral<"sha256">;
+    digest: z.ZodString;
+}, z.core.$strict>;
+export declare const TransformProofOperandValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+    algorithm: z.ZodLiteral<"sha256">;
+    digest: z.ZodString;
+}, z.core.$strict>]>;
+export declare function isTrustedTransformDocsHref(href: string): boolean;
+export declare function trustedTransformDocsHref(methodId?: string): string;
+export declare function trustedIntentParametersFitProof(parameters: unknown): boolean;
+export declare const TransformProofSchema: z.ZodObject<{
+    methodId: z.ZodString;
+    methodVersion: z.ZodNumber;
+    result: z.ZodEnum<{
+        verified: "verified";
+        contradicted: "contradicted";
+        not_applicable: "not_applicable";
+    }>;
+    proofClass: z.ZodEnum<{
+        safe_equivalence: "safe_equivalence";
+        exact_conversion: "exact_conversion";
+        policy_application: "policy_application";
+    }>;
+    scope: z.ZodString;
+    trustedParameters: z.ZodRecord<z.ZodString, z.ZodType<string | number | boolean | z.core.util.JSONType[] | {
+        [key: string]: z.core.util.JSONType;
+    } | null, unknown, z.core.$ZodTypeInternals<string | number | boolean | z.core.util.JSONType[] | {
+        [key: string]: z.core.util.JSONType;
+    } | null, unknown>>>;
+    operands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<string | number | boolean | {
+        algorithm: "sha256";
+        digest: string;
+    }, unknown, z.core.$ZodTypeInternals<string | number | boolean | {
+        algorithm: "sha256";
+        digest: string;
+    }, unknown>>>>;
+    checks: z.ZodRecord<z.ZodString, z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>>;
+    implementation: z.ZodObject<{
+        library: z.ZodString;
+        version: z.ZodString;
+        runtime: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodString>;
+        zone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    limitations: z.ZodString;
+    docsHref: z.ZodString;
+}, z.core.$strict>;
+export type TransformProof = z.infer<typeof TransformProofSchema>;
+export declare function parseTransformProof(value: unknown): TransformProof | undefined;
+export type TransformVerificationResult = {
+    result: TransformProof['result'];
+    proof: TransformProof;
+};
+export type TransformValidatorDescriptor = {
+    operation: TransformOperation;
+    methodId: string;
+    version: number;
+    label: string;
+    summary: string;
+    docsAnchor: TransformDocsAnchor;
+    acceptedSourceTypes: readonly string[];
+    acceptedOutputTypes: readonly string[];
+    proofClass: TransformProofClass;
+    parameterSchema: z.ZodType;
+    parameterJsonSchema: Record<string, unknown>;
+    library: {
+        name: string;
+        version: string;
+    };
+    limitations: string;
+    verify(input: {
+        quote: string;
+        output: unknown;
+        parameters: unknown;
+        preferredSourceFormat?: string;
+    }): TransformVerificationResult;
+};
+export declare const TRANSFORM_VALIDATORS: readonly [TransformValidatorDescriptor, TransformValidatorDescriptor, TransformValidatorDescriptor, TransformValidatorDescriptor, TransformValidatorDescriptor, TransformValidatorDescriptor, TransformValidatorDescriptor, TransformValidatorDescriptor];
+export declare function transformValidatorDescriptor(operation: TransformOperation): TransformValidatorDescriptor;
+/** Verify only the validator selected by trusted request intent. Model claims never authorize it. */
+export declare function verifyTransform(input: {
+    quote: string;
+    output: unknown;
+    intent: TransformIntent;
+    claim?: TransformClaim;
+}): TransformVerificationResult;
+//# sourceMappingURL=transform-validation.d.ts.map

package/dist/profile/transform-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-validation.d.ts","sourceRoot":"","sources":["../../src/profile/transform-validation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,2BAA2B,0EACiC,CAAC;AAC1E,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AACrE,eAAO,MAAM,yBAAyB,OAAQ,CAAC;AAC/C,6FAA6F;AAC7F,eAAO,MAAM,oCAAoC,OAAQ,CAAC;AAE1D,eAAO,MAAM,sBAAsB,gKASzB,CAAC;AACX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E,eAAO,MAAM,yBAAyB;;;;EAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;AA0KzD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,YAAY,EAClB,aAAa,EAAE,MAAM,EAAE,EACvB,YAAY,EAAE,MAAM,GACnB,MAAM,GAAG,SAAS,CAepB;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,EAAG,0CAAmD,CAAC;AAC1F,eAAO,MAAM,2BAA2B,EAAG,CAAU,CAAC;AACtD,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AACX,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAkB1E,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,YAAY,EAClB,YAAY,GAAE,MAAuC,GACpD,MAAM,EAAE,CAIV;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,YAAY;;;;;;;;;;EAY9D;AAkHD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwBhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;AAE9D,eAAO,MAAM,oBAAoB,gKASiB,CAAC;AAEnD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;kBAUtB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,4BAA4B,4QAkB/B,CAAC;AAcX,eAAO,MAAM,wBAAwB;;;kBAK1B,CAAC;AAEZ,eAAO,MAAM,gCAAgC;;;oBAK3C,CAAC;AAQH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMhE;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAMlE;AAKD,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO,CAE5E;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyC7B,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAqB9E;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IACjC,KAAK,EAAE,cAAc,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,mBAAmB,CAAC;IAChC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,UAAU,EAAE,mBAAmB,CAAC;IAChC,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,KAAK,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,OAAO,CAAC;QAChB,UAAU,EAAE,OAAO,CAAC;QACpB,qBAAqB,CAAC,EAAE,MAAM,CAAC;KAChC,GAAG,2BAA2B,CAAC;CACjC,CAAC;AA2sBF,eAAO,MAAM,oBAAoB,2PAS2B,CAAC;AAM7D,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,kBAAkB,GAC5B,4BAA4B,CAE9B;AAQD,qGAAqG;AACrG,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB,GAAG,2BAA2B,CAU9B"}

package/dist/prov.d.ts

@@ -0,0 +1,40 @@
+import type { LineageDocument } from './document.js';
+/**
+ * Subset of W3C PROV-JSON used for interoperability export.
+ *
+ * Note: PROV-JSON itself is a W3C Member Submission
+ * (https://www.w3.org/Submission/2013/SUBM-prov-json-20130424/).
+ * The conceptual model is PROV-DM, a W3C Recommendation
+ * (https://www.w3.org/TR/prov-dm/).
+ */
+export type ProvJsonDocument = {
+    prefix?: Record<string, string>;
+    entity?: Record<string, Record<string, unknown>>;
+    activity?: Record<string, Record<string, unknown>>;
+    agent?: Record<string, Record<string, unknown>>;
+    wasDerivedFrom?: Record<string, Record<string, unknown>>;
+    wasGeneratedBy?: Record<string, Record<string, unknown>>;
+    used?: Record<string, Record<string, unknown>>;
+    wasAssociatedWith?: Record<string, Record<string, unknown>>;
+    wasAttributedTo?: Record<string, Record<string, unknown>>;
+    hadMember?: Record<string, Record<string, unknown>>;
+    specializationOf?: Record<string, Record<string, unknown>>;
+    alternateOf?: Record<string, Record<string, unknown>>;
+};
+/**
+ * Where the `lineage@1` vocabulary is published, so PROV consumers can resolve
+ * the `lineage:` prefix. It names the format, not a producer — a document emitted
+ * by anyone binds the same prefix. Moving it breaks every consumer that has
+ * already resolved a term against it, so it is versioned with the format itself.
+ */
+export declare const LINEAGE_PROV_NAMESPACE = "https://openparser.dev/ns/lineage#";
+export declare function lineageIdToProvQualifiedName(id: string): string;
+/**
+ * Map a validated `lineage@1` document to W3C PROV-JSON concepts.
+ *
+ * Derivations expand to `wasDerivedFrom` (per input), `wasGeneratedBy`
+ * (output ← activity), and `used` (activity ← input). Associations,
+ * attributions, and membership follow PROV relations.
+ */
+export declare function toProvJson(doc: LineageDocument): ProvJsonDocument;
+//# sourceMappingURL=prov.d.ts.map

package/dist/prov.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prov.d.ts","sourceRoot":"","sources":["../src/prov.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5D,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpD,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,uCAAuC,CAAC;AAE3E,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAK/D;AAGD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,eAAe,GAAG,gBAAgB,CA0IjE"}

package/dist/relation.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const RELATION_TYPES: readonly ["member_of", "specialization_of", "alternate_of"];
+export declare const RelationTypeSchema: z.ZodEnum<{
+    member_of: "member_of";
+    specialization_of: "specialization_of";
+    alternate_of: "alternate_of";
+}>;
+export type RelationType = z.infer<typeof RelationTypeSchema>;
+/**
+ * Semantic entity–entity relations outside the derivation DAG.
+ *
+ * - `member_of`: `source` is a member; `target` must be a `collection` entity
+ * - `specialization_of`: `source` specializes `target` (PROV specializationOf)
+ * - `alternate_of`: `source` and `target` are alternate of each other
+ */
+export declare const RelationSchema: 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>;
+export type Relation = z.infer<typeof RelationSchema>;
+//# sourceMappingURL=relation.d.ts.map

package/dist/relation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation.d.ts","sourceRoot":"","sources":["../src/relation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,cAAc,6DAA8D,CAAC;AAC1F,eAAO,MAAM,kBAAkB;;;;EAAyB,CAAC;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;kBAgBvB,CAAC;AACL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/traverse.d.ts

@@ -0,0 +1,12 @@
+import type { LineageDocument } from './document.js';
+/**
+ * Topological order of entity ids following derivation dependencies
+ * (inputs before outputs). Stable for disconnected nodes by insertion order
+ * of `Object.keys(entities)`.
+ */
+export declare function topologicalEntityOrder(doc: LineageDocument): string[];
+/** All entities reachable upstream via derivation inputs (transitive). */
+export declare function entityAncestors(doc: LineageDocument, entityId: string): string[];
+/** All entities reachable downstream via derivation outputs (transitive). */
+export declare function entityDescendants(doc: LineageDocument, entityId: string): string[];
+//# sourceMappingURL=traverse.d.ts.map

package/dist/traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../src/traverse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA8BlD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,EAAE,CA8BrE;AAiBD,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhF;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAElF"}

package/dist/validate.d.ts

@@ -0,0 +1,14 @@
+import type { LineageDocument } from './document.js';
+export declare class LineageValidationError extends Error {
+    readonly issues: string[];
+    constructor(issues: string[]);
+}
+/**
+ * Strict graph validation beyond Zod shape checks.
+ *
+ * Ensures globally distinct ids, resolvable references, unique derivation
+ * outputs (one producer), no self-inputs, acyclic entity dependencies,
+ * valid collection membership, and coherent activity timestamps.
+ */
+export declare function validateLineageGraph(doc: LineageDocument): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;gBAEd,MAAM,EAAE,MAAM,EAAE;CAK7B;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CAwM/D"}