@elaraai/east 0.0.1-beta.3 → 0.0.1-beta.30

package/dist/src/patch/diff.js

@@ -0,0 +1,328 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * diffFor - Compute difference between two East values.
+ *
+ * @module
+ */
+import { toEastTypeValue } from "../type_of_type.js";
+import { isVariant, variant } from "../containers/variant.js";
+import { equalFor, isFor, compareFor } from "../comparison.js";
+import { SortedMap } from "../containers/sortedmap.js";
+import { SortedSet } from "../containers/sortedset.js";
+import { computeLCS } from "./types.js";
+export function diffFor(type, ctx = { diff: [], types: [], equal: [] }) {
+    // Convert to EastTypeValue and use a properly typed variable
+    const t = isVariant(type) ? type : toEastTypeValue(type);
+    if (t.type === "Never") {
+        return (_before, _after) => {
+            throw new Error("Cannot diff values of type Never");
+        };
+    }
+    else if (t.type === "Null" ||
+        t.type === "Boolean" ||
+        t.type === "Integer" ||
+        t.type === "Float" ||
+        t.type === "String" ||
+        t.type === "DateTime" ||
+        t.type === "Blob") {
+        const equal = equalFor(t);
+        return (before, after) => {
+            if (equal(before, after)) {
+                return variant("unchanged", null);
+            }
+            return variant("replace", { before, after });
+        };
+    }
+    else if (t.type === "Array") {
+        let elementEqual;
+        let is;
+        const ret = (before, after) => {
+            if (is(before, after)) {
+                return variant("unchanged", null);
+            }
+            const { beforeIndices, afterIndices } = computeLCS(before, after, elementEqual);
+            const operations = [];
+            let beforePtr = 0;
+            let afterPtr = 0;
+            let lcsPtr = 0;
+            let deleteCount = 0;
+            let insertCount = 0; // Track inserts that shift subsequent delete positions
+            while (beforePtr < before.length || afterPtr < after.length) {
+                const nextBeforeLCS = lcsPtr < beforeIndices.length ? beforeIndices[lcsPtr] : before.length;
+                const nextAfterLCS = lcsPtr < afterIndices.length ? afterIndices[lcsPtr] : after.length;
+                while (beforePtr < nextBeforeLCS) {
+                    // For deletes: key is the position in the mutating array
+                    // We need to account for:
+                    // - Previous deletes (which shrink the array)
+                    // - Previous inserts (which grow the array and shift positions)
+                    const actualPosition = beforePtr - deleteCount + insertCount;
+                    operations.push({
+                        key: BigInt(actualPosition),
+                        offset: 0n,
+                        operation: variant("delete", before[beforePtr]),
+                    });
+                    deleteCount++;
+                    beforePtr++;
+                }
+                while (afterPtr < nextAfterLCS) {
+                    // For inserts: key is the position in the target array
+                    operations.push({
+                        key: BigInt(afterPtr),
+                        offset: 0n,
+                        operation: variant("insert", after[afterPtr]),
+                    });
+                    insertCount++;
+                    afterPtr++;
+                }
+                if (lcsPtr < beforeIndices.length) {
+                    beforePtr++;
+                    afterPtr++;
+                    lcsPtr++;
+                }
+            }
+            if (operations.length === 0) {
+                return variant("unchanged", null);
+            }
+            return variant("patch", operations);
+        };
+        // Build array equality using equalFor with current context
+        // This must be pushed BEFORE recursing so children can reference it via .Recursive
+        const arrayEqual = equalFor(t, ctx.equal);
+        ctx.diff.push(ret);
+        ctx.types.push(t);
+        ctx.equal.push(arrayEqual);
+        is = isFor(t, ctx.equal);
+        elementEqual = equalFor(t.value, ctx.equal);
+        ctx.diff.pop();
+        ctx.types.pop();
+        ctx.equal.pop();
+        return ret;
+    }
+    else if (t.type === "Set") {
+        // Set keys cannot contain recursive types, so no context needed
+        const is = isFor(t);
+        const keyCompare = compareFor(t.value);
+        return (before, after) => {
+            if (is(before, after)) {
+                return variant("unchanged", null);
+            }
+            const operations = new SortedMap(undefined, keyCompare);
+            for (const key of before) {
+                if (!after.has(key)) {
+                    operations.set(key, variant("delete", null));
+                }
+            }
+            for (const key of after) {
+                if (!before.has(key)) {
+                    operations.set(key, variant("insert", null));
+                }
+            }
+            if (operations.size === 0) {
+                return variant("unchanged", null);
+            }
+            let deleteCount = 0;
+            let insertCount = 0;
+            for (const op of operations.values()) {
+                if (op.type === "delete")
+                    deleteCount++;
+                if (op.type === "insert")
+                    insertCount++;
+            }
+            if (deleteCount === before.size && insertCount === after.size && before.size > 0) {
+                return variant("replace", { before, after });
+            }
+            return variant("patch", operations);
+        };
+    }
+    else if (t.type === "Dict") {
+        let valueDiff;
+        let valueEqual;
+        let is;
+        // Dict keys cannot contain recursive types, so no context needed for keyCompare
+        const keyCompare = compareFor(t.value.key);
+        const ret = (before, after) => {
+            if (is(before, after)) {
+                return variant("unchanged", null);
+            }
+            const operations = new SortedMap(undefined, keyCompare);
+            for (const [key, beforeValue] of before) {
+                if (!after.has(key)) {
+                    operations.set(key, variant("delete", beforeValue));
+                }
+                else {
+                    const afterValue = after.get(key);
+                    if (!valueEqual(beforeValue, afterValue)) {
+                        const patch = valueDiff(beforeValue, afterValue);
+                        operations.set(key, variant("update", patch));
+                    }
+                }
+            }
+            for (const [key, afterValue] of after) {
+                if (!before.has(key)) {
+                    operations.set(key, variant("insert", afterValue));
+                }
+            }
+            if (operations.size === 0) {
+                return variant("unchanged", null);
+            }
+            let insertCount = 0;
+            let deleteCount = 0;
+            for (const op of operations.values()) {
+                if (op.type === "insert")
+                    insertCount++;
+                if (op.type === "delete")
+                    deleteCount++;
+            }
+            if (insertCount === after.size && deleteCount === before.size && before.size > 0) {
+                return variant("replace", { before, after });
+            }
+            return variant("patch", operations);
+        };
+        // Build dict equality using equalFor with current context
+        // This must be pushed BEFORE recursing so children can reference it via .Recursive
+        const dictEqual = equalFor(t, ctx.equal);
+        ctx.diff.push(ret);
+        ctx.types.push(t);
+        ctx.equal.push(dictEqual);
+        is = isFor(t, ctx.equal);
+        valueDiff = diffFor(t.value.value, ctx);
+        valueEqual = equalFor(t.value.value, ctx.equal);
+        ctx.diff.pop();
+        ctx.types.pop();
+        ctx.equal.pop();
+        return ret;
+    }
+    else if (t.type === "Struct") {
+        const fieldDiffs = {};
+        const fieldEquals = {};
+        const ret = (before, after) => {
+            if (before === after) {
+                return variant("unchanged", null);
+            }
+            const patchFields = {};
+            let allUnchanged = true;
+            for (const { name } of t.value) {
+                const beforeValue = before[name];
+                const afterValue = after[name];
+                if (fieldEquals[name](beforeValue, afterValue)) {
+                    patchFields[name] = variant("unchanged", null);
+                }
+                else {
+                    patchFields[name] = fieldDiffs[name](beforeValue, afterValue);
+                    allUnchanged = false;
+                }
+            }
+            if (allUnchanged) {
+                return variant("unchanged", null);
+            }
+            return variant("patch", patchFields);
+        };
+        // Build struct equality using equalFor with current context
+        // This must be pushed BEFORE recursing so children can reference it via .Recursive
+        const structEqual = equalFor(t, ctx.equal);
+        ctx.diff.push(ret);
+        ctx.types.push(t);
+        ctx.equal.push(structEqual);
+        for (const { name, type: fieldType } of t.value) {
+            fieldDiffs[name] = diffFor(fieldType, ctx);
+            fieldEquals[name] = equalFor(fieldType, ctx.equal);
+        }
+        ctx.diff.pop();
+        ctx.types.pop();
+        ctx.equal.pop();
+        return ret;
+    }
+    else if (t.type === "Variant") {
+        const caseDiffs = {};
+        const caseEquals = {};
+        const ret = (before, after) => {
+            if (before === after) {
+                return variant("unchanged", null);
+            }
+            if (before.type !== after.type) {
+                return variant("replace", { before, after });
+            }
+            const caseName = before.type;
+            if (caseEquals[caseName](before.value, after.value)) {
+                return variant("unchanged", null);
+            }
+            const casePatch = caseDiffs[caseName](before.value, after.value);
+            if (casePatch.type === "unchanged") {
+                return variant("unchanged", null);
+            }
+            return variant("patch", variant(caseName, casePatch));
+        };
+        // Build variant equality using equalFor with current context
+        const variantEqual = equalFor(t, ctx.equal);
+        ctx.diff.push(ret);
+        ctx.types.push(t);
+        ctx.equal.push(variantEqual);
+        for (const { name, type: caseType } of t.value) {
+            caseDiffs[name] = diffFor(caseType, ctx);
+            caseEquals[name] = equalFor(caseType, ctx.equal);
+        }
+        ctx.diff.pop();
+        ctx.types.pop();
+        ctx.equal.pop();
+        return ret;
+    }
+    else if (t.type === "Ref") {
+        let innerDiff;
+        let innerEqual;
+        let is;
+        const ret = (before, after) => {
+            if (is(before, after)) {
+                return variant("unchanged", null);
+            }
+            if (innerEqual(before.value, after.value)) {
+                return variant("unchanged", null);
+            }
+            const innerPatch = innerDiff(before.value, after.value);
+            if (innerPatch.type === "unchanged") {
+                return variant("unchanged", null);
+            }
+            return variant("patch", innerPatch);
+        };
+        // Build ref equality using equalFor with current context
+        // This must be pushed BEFORE recursing so children can reference it via .Recursive
+        const refEqual = equalFor(t, ctx.equal);
+        ctx.diff.push(ret);
+        ctx.types.push(t);
+        ctx.equal.push(refEqual);
+        is = isFor(t, ctx.equal);
+        innerDiff = diffFor(t.value, ctx);
+        innerEqual = equalFor(t.value, ctx.equal);
+        ctx.diff.pop();
+        ctx.types.pop();
+        ctx.equal.pop();
+        return ret;
+    }
+    else if (t.type === "Recursive") {
+        // Recursive types use replace-only semantics - no structural patching.
+        // Look up the type and equality function from context, but always replace.
+        const resolvedType = ctx.types[ctx.types.length - Number(t.value)];
+        if (resolvedType === undefined) {
+            throw new Error(`Internal error: Recursive type context not found in diffFor`);
+        }
+        const equal = ctx.equal[ctx.equal.length - Number(t.value)];
+        if (equal === undefined) {
+            throw new Error(`Internal error: Recursive equal context not found in diffFor`);
+        }
+        return (before, after) => {
+            if (equal(before, after)) {
+                return variant("unchanged", null);
+            }
+            return variant("replace", { before, after });
+        };
+    }
+    else if (t.type === "Function" || t.type === "AsyncFunction") {
+        return (_before, _after) => variant("unchanged", null);
+    }
+    else {
+        throw new Error(`Unhandled type in diffFor: ${t.type}`);
+    }
+}
+//# sourceMappingURL=diff.js.map

package/dist/src/patch/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../../src/patch/diff.ts"],"names":[],"mappings":"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"}

package/dist/src/patch/fuzz.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Fuzz testing configuration for patch operations.
+ * Shared between unit tests (src/patch/patch.spec.ts) and compliance tests (test/patch.spec.ts).
+ *
+ * @module
+ */
+import type { EastType, ValueTypeOf, ArrayType as ArrayTypeT, StructType as StructTypeT } from "../types.js";
+/**
+ * A generated test case containing a random type and sample values for testing.
+ */
+export interface FuzzTestCase<T extends EastType = EastType> {
+    /** The randomly generated East type */
+    type: T;
+    /** String representation of the type for test naming */
+    typeName: string;
+    /** Array type for before/after pairs (used by compliance tests) */
+    pairsArrayType: ArrayTypeT<StructTypeT<{
+        before: T;
+        after: T;
+    }>>;
+    /** Array type for v1/v2/v3 triplets (used by compliance tests) */
+    tripletsArrayType: ArrayTypeT<StructTypeT<{
+        v1: T;
+        v2: T;
+        v3: T;
+    }>>;
+    /** Value pairs for diff/apply/invert tests */
+    pairs: Array<{
+        before: ValueTypeOf<T>;
+        after: ValueTypeOf<T>;
+    }>;
+    /** Value triplets for compose tests */
+    triplets: Array<{
+        v1: ValueTypeOf<T>;
+        v2: ValueTypeOf<T>;
+        v3: ValueTypeOf<T>;
+    }>;
+}
+/**
+ * Options for generating fuzz test cases.
+ */
+export interface FuzzTestOptions {
+    /** Number of random types to generate */
+    numTypes?: number;
+    /** Number of sample values per type */
+    numSamples?: number;
+    /** Include recursive types in generation */
+    includeRecursive?: boolean;
+    /** Include function types in generation */
+    includeFunctions?: boolean;
+    /** Maximum retries when generating values for a single type */
+    maxValueRetries?: number;
+    /** Multiplier for max attempts (numTypes * multiplier) */
+    attemptsMultiplier?: number;
+    /** Ensure diverse type coverage (at least one of each kind) */
+    ensureDiversity?: boolean;
+}
+/**
+ * Generate fuzz test cases with random types and values.
+ *
+ * This function generates random East types and corresponding sample values
+ * for testing patch operations. It handles recursive types gracefully by
+ * retrying value generation when max recursion depth is exceeded.
+ *
+ * @param options Configuration options
+ * @returns Array of test cases
+ */
+export declare function generateFuzzTestCases(options?: FuzzTestOptions): FuzzTestCase[];
+//# sourceMappingURL=fuzz.d.ts.map

package/dist/src/patch/fuzz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzz.d.ts","sourceRoot":"","sources":["../../../src/patch/fuzz.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,IAAI,UAAU,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,aAAa,CAAC;AAkB7G;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACvD,uCAAuC;IACvC,IAAI,EAAE,CAAC,CAAC;IACR,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC;QAAE,MAAM,EAAE,CAAC,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC,CAAC;IACjE,kEAAkE;IAClE,iBAAiB,EAAE,UAAU,CAAC,WAAW,CAAC;QAAE,EAAE,EAAE,CAAC,CAAC;QAAC,EAAE,EAAE,CAAC,CAAC;QAAC,EAAE,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC,CAAC;IACpE,8CAA8C;IAC9C,KAAK,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;QAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC,CAAC;IAChE,uCAAuC;IACvC,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;QAAC,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;QAAC,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC,CAAC;CACnF;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,2CAA2C;IAC3C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,0DAA0D;IAC1D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,+DAA+D;IAC/D,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B;AA0ED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,eAAoB,GAAG,YAAY,EAAE,CA6FnF"}

package/dist/src/patch/fuzz.js

@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, StructType, VariantType, DictType, SetType, RefType, FunctionType, IntegerType, StringType, FloatType, BooleanType, NullType, printType, } from "../types.js";
+import { randomType, randomValueFor, randomRecursiveType, randomFunctionType } from "../fuzz.js";
+const DEFAULT_OPTIONS = {
+    numTypes: 20,
+    numSamples: 5,
+    includeRecursive: true,
+    includeFunctions: true,
+    maxValueRetries: 20,
+    attemptsMultiplier: 3,
+    ensureDiversity: true,
+};
+/**
+ * Specific type generators to ensure diversity in test coverage.
+ * These guarantee we test important type patterns that random generation might miss.
+ */
+function getDiverseTypes(includeRecursive, includeFunctions) {
+    const types = [
+        // Variants (often missed by random generation)
+        VariantType({ none: NullType, some: IntegerType }),
+        VariantType({ ok: StringType, err: StructType({ code: IntegerType, message: StringType }) }),
+        // Nested variants
+        VariantType({
+            leaf: FloatType,
+            branch: ArrayType(IntegerType),
+        }),
+        // Ref types
+        RefType(IntegerType),
+        RefType(StructType({ x: FloatType, y: FloatType })),
+        // Nested collections
+        ArrayType(VariantType({ a: IntegerType, b: StringType })),
+        DictType(StringType, VariantType({ value: FloatType, missing: NullType })),
+        // Struct with variant field
+        StructType({
+            id: IntegerType,
+            status: VariantType({ active: NullType, inactive: StringType }),
+        }),
+        // Set with different key types
+        SetType(IntegerType),
+        // Deeply nested
+        ArrayType(ArrayType(IntegerType)),
+        DictType(StringType, DictType(StringType, IntegerType)),
+    ];
+    // Add recursive types if enabled
+    if (includeRecursive) {
+        // Add multiple recursive type patterns
+        for (let i = 0; i < 3; i++) {
+            types.push(randomRecursiveType());
+        }
+    }
+    // Add function types if enabled
+    if (includeFunctions) {
+        types.push(
+        // Simple function
+        FunctionType([IntegerType], StringType), 
+        // Function with multiple args
+        FunctionType([IntegerType, StringType], BooleanType), 
+        // Random function types
+        randomFunctionType(), randomFunctionType());
+    }
+    return types;
+}
+/**
+ * Generate fuzz test cases with random types and values.
+ *
+ * This function generates random East types and corresponding sample values
+ * for testing patch operations. It handles recursive types gracefully by
+ * retrying value generation when max recursion depth is exceeded.
+ *
+ * @param options Configuration options
+ * @returns Array of test cases
+ */
+export function generateFuzzTestCases(options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const testCases = [];
+    const seenTypes = new Set();
+    // Helper to try adding a type to test cases
+    const tryAddType = (type) => {
+        const typeName = printType(type);
+        // Skip duplicates
+        if (seenTypes.has(typeName)) {
+            return false;
+        }
+        try {
+            const genValue = randomValueFor(type);
+            // Helper to safely generate a value (retry on depth exceeded)
+            const safeGenValue = () => {
+                for (let retry = 0; retry < opts.maxValueRetries; retry++) {
+                    try {
+                        return genValue();
+                    }
+                    catch (e) {
+                        if (e.message?.includes("max recursion depth")) {
+                            continue;
+                        }
+                        throw e;
+                    }
+                }
+                throw new Error("max recursion depth");
+            };
+            // Generate value pairs
+            const pairs = [];
+            for (let j = 0; j < opts.numSamples; j++) {
+                pairs.push({ before: safeGenValue(), after: safeGenValue() });
+            }
+            // Generate triplets for compose tests
+            const triplets = [];
+            for (let j = 0; j < opts.numSamples; j++) {
+                triplets.push({ v1: safeGenValue(), v2: safeGenValue(), v3: safeGenValue() });
+            }
+            // Create array types for East runtime iteration
+            const pairsArrayType = ArrayType(StructType({ before: type, after: type }));
+            const tripletsArrayType = ArrayType(StructType({ v1: type, v2: type, v3: type }));
+            seenTypes.add(typeName);
+            testCases.push({
+                type,
+                typeName,
+                pairsArrayType,
+                tripletsArrayType,
+                pairs,
+                triplets,
+            });
+            return true;
+        }
+        catch (e) {
+            // Skip types that fail to generate values
+            if (e.message?.includes("max recursion depth")) {
+                return false;
+            }
+            throw e;
+        }
+    };
+    // First, add diverse types to ensure coverage
+    if (opts.ensureDiversity) {
+        const diverseTypes = getDiverseTypes(opts.includeRecursive, opts.includeFunctions);
+        for (const type of diverseTypes) {
+            if (testCases.length >= opts.numTypes)
+                break;
+            tryAddType(type);
+        }
+    }
+    // Fill remaining slots with random types
+    let attempts = 0;
+    const maxAttempts = opts.numTypes * opts.attemptsMultiplier;
+    while (testCases.length < opts.numTypes && attempts < maxAttempts) {
+        attempts++;
+        // Generate a random type
+        const type = randomType(0, {
+            includeRecursive: opts.includeRecursive,
+            includeFunctions: opts.includeFunctions,
+        });
+        tryAddType(type);
+    }
+    return testCases;
+}
+//# sourceMappingURL=fuzz.js.map

package/dist/src/patch/fuzz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzz.js","sourceRoot":"","sources":["../../../src/patch/fuzz.ts"],"names":[],"mappings":"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"}

package/dist/src/patch/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Patch system for computing and applying differences between East values.
+ *
+ * Provides four core operations:
+ * - `diffFor(type)` - Compute the difference between two values
+ * - `applyFor(type)` - Apply a patch to a value
+ * - `composeFor(type)` - Combine two sequential patches
+ * - `invertFor(type)` - Invert a patch
+ *
+ * @module
+ */
+export { type PatchTypeOf, ConflictError, } from "./types.js";
+export { PatchType } from "./type_of_patch.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/patch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/patch/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAGH,OAAO,EACL,KAAK,WAAW,EAChB,aAAa,GACd,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/src/patch/index.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Patch system for computing and applying differences between East values.
+ *
+ * Provides four core operations:
+ * - `diffFor(type)` - Compute the difference between two values
+ * - `applyFor(type)` - Apply a patch to a value
+ * - `composeFor(type)` - Combine two sequential patches
+ * - `invertFor(type)` - Invert a patch
+ *
+ * @module
+ */
+// Re-export types for public API
+export { ConflictError, } from "./types.js";
+// Re-export PatchType constructor
+export { PatchType } from "./type_of_patch.js";
+//# sourceMappingURL=index.js.map

package/dist/src/patch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/patch/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH,iCAAiC;AACjC,OAAO,EAEL,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,kCAAkC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/src/patch/invert.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * invertFor - Invert a patch.
+ *
+ * @module
+ */
+import { type EastTypeValue } from "../type_of_type.js";
+import type { EastType } from "../types.js";
+import { type InvertContext } from "./types.js";
+export declare function invertFor(type: EastTypeValue, ctx?: InvertContext): (patch: any) => any;
+export declare function invertFor<T extends EastType>(type: T): (patch: any) => any;
+//# sourceMappingURL=invert.d.ts.map

package/dist/src/patch/invert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../src/patch/invert.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AAEH,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAI5C,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;AACzF,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC"}