@panproto/core 0.5.1 → 0.7.0

package/dist/index.d.ts

@@ -24,16 +24,18 @@ export { Protocol } from './protocol.js';
 export { ATPROTO_SPEC, SQL_SPEC, PROTOBUF_SPEC, GRAPHQL_SPEC, JSON_SCHEMA_SPEC, BUILTIN_PROTOCOLS, getProtocolNames, getBuiltinProtocol, } from './protocol.js';
 export { SchemaBuilder, BuiltSchema } from './schema.js';
 export { MigrationBuilder, CompiledMigration } from './migration.js';
-export { renameField, addField, removeField, wrapInObject, hoistField, coerceType, compose, pipeline, LensHandle, fromCombinators, } from './lens.js';
-export type { Combinator, RenameFieldCombinator, AddFieldCombinator, RemoveFieldCombinator, WrapInObjectCombinator, HoistFieldCombinator, CoerceTypeCombinator, ComposeCombinator, } from './lens.js';
+export { LensHandle, ProtolensChainHandle, SymmetricLensHandle, } from './lens.js';
+export type { SchemaTransform, ProtolensSpec, ProtolensChainSpec, ComplementSpec, DefaultRequirement, CapturedField, ElementaryStep, NaturalityResult, } from './protolens.js';
 export { Instance } from './instance.js';
 export { IoRegistry, PROTOCOL_CATEGORIES } from './io.js';
 export { FullDiffReport, CompatReport, ValidationResult } from './check.js';
 export type { FullSchemaDiff, CompatReportData, BreakingChange, NonBreakingChange, ConstraintChange, ConstraintDiff, KindChange, SchemaValidationIssue, } from './types.js';
 export type { LawCheckResult, ProtocolSpec, EdgeRule, Vertex, Edge, HyperEdge, Constraint, Variant, RecursionPoint, UsageMode, Span, VertexOptions, EdgeOptions, SchemaData, MigrationSpec, LiftResult, GetResult, DiffReport, SchemaChange, Compatibility, ExistenceReport, ExistenceError, WasmModule, WasmExports, InstanceShape, InstanceValidationResult, } from './types.js';
-export { TheoryHandle, TheoryBuilder, createTheory, colimit, checkMorphism, migrateModel, } from './gat.js';
+export { TheoryHandle, TheoryBuilder, createTheory, colimit, checkMorphism, migrateModel, factorizeMorphism, } from './gat.js';
 export type { TheorySpec, TheoryMorphism, Sort, SortParam, GatOperation, Equation, Term, MorphismCheckResult, } from './types.js';
 export { Repository } from './vcs.js';
+export { DataSetHandle } from './data.js';
+export type { MigrationResult, StalenessResult } from './data.js';
 export type { VcsLogEntry, VcsStatus, VcsOpResult, VcsBlameResult, } from './types.js';
 export type { WasmGlueModule } from './wasm.js';
 export { PanprotoError, WasmError, SchemaValidationError, MigrationError, ExistenceCheckError, } from './types.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAGzD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGrE,OAAO,EACL,WAAW,EACX,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,UAAU,EACV,UAAU,EACV,OAAO,EACP,QAAQ,EACR,UAAU,EACV,eAAe,GAChB,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,UAAU,EACV,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAG1D,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC5E,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,qBAAqB,GACtB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,SAAS,EACT,UAAU,EACV,OAAO,EACP,cAAc,EACd,SAAS,EACT,IAAI,EACJ,aAAa,EACb,WAAW,EACX,UAAU,EACV,aAAa,EACb,UAAU,EACV,SAAS,EACT,UAAU,EACV,YAAY,EACZ,aAAa,EACb,eAAe,EACf,cAAc,EACd,UAAU,EACV,WAAW,EACX,aAAa,EACb,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,OAAO,EACP,aAAa,EACb,YAAY,GACb,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,UAAU,EACV,cAAc,EACd,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,IAAI,EACJ,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,cAAc,GACf,MAAM,YAAY,CAAC;AAGpB,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGhD,OAAO,EACL,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,cAAc,EACd,mBAAmB,GACpB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAGzD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGrE,OAAO,EACL,UAAU,EACV,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAGnB,YAAY,EACV,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,cAAc,EACd,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAG1D,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC5E,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,qBAAqB,GACtB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,SAAS,EACT,UAAU,EACV,OAAO,EACP,cAAc,EACd,SAAS,EACT,IAAI,EACJ,aAAa,EACb,WAAW,EACX,UAAU,EACV,aAAa,EACb,UAAU,EACV,SAAS,EACT,UAAU,EACV,YAAY,EACZ,aAAa,EACb,eAAe,EACf,cAAc,EACd,UAAU,EACV,WAAW,EACX,aAAa,EACb,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,OAAO,EACP,aAAa,EACb,YAAY,EACZ,iBAAiB,GAClB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,UAAU,EACV,cAAc,EACd,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,IAAI,EACJ,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGtC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAClE,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,cAAc,GACf,MAAM,YAAY,CAAC;AAGpB,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGhD,OAAO,EACL,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,cAAc,EACd,mBAAmB,GACpB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -68,7 +68,21 @@ async function loadWasm(input) {
       get_json: glue.get_json,
       put_json: glue.put_json,
       instance_element_count: glue.instance_element_count,
-      lens_from_combinators: glue.lens_from_combinators,
+      auto_generate_protolens: glue.auto_generate_protolens,
+      instantiate_protolens: glue.instantiate_protolens,
+      protolens_complement_spec: glue.protolens_complement_spec,
+      protolens_from_diff: glue.protolens_from_diff,
+      protolens_compose: glue.protolens_compose,
+      protolens_chain_to_json: glue.protolens_chain_to_json,
+      factorize_morphism: glue.factorize_morphism,
+      symmetric_lens_from_schemas: glue.symmetric_lens_from_schemas,
+      symmetric_lens_sync: glue.symmetric_lens_sync,
+      apply_protolens_step: glue.apply_protolens_step,
+      protolens_from_json: glue.protolens_from_json,
+      protolens_fuse: glue.protolens_fuse,
+      protolens_lift: glue.protolens_lift,
+      protolens_check_applicability: glue.protolens_check_applicability,
+      protolens_fleet: glue.protolens_fleet,
       check_lens_laws: glue.check_lens_laws,
       check_get_put: glue.check_get_put,
       check_put_get: glue.check_put_get,
@@ -94,7 +108,16 @@ async function loadWasm(input) {
       vcs_merge: glue.vcs_merge,
       vcs_stash: glue.vcs_stash,
       vcs_stash_pop: glue.vcs_stash_pop,
-      vcs_blame: glue.vcs_blame
+      vcs_blame: glue.vcs_blame,
+      // Phase 7: Data versioning
+      store_dataset: glue.store_dataset,
+      get_dataset: glue.get_dataset,
+      migrate_dataset_forward: glue.migrate_dataset_forward,
+      migrate_dataset_backward: glue.migrate_dataset_backward,
+      check_dataset_staleness: glue.check_dataset_staleness,
+      store_protocol_definition: glue.store_protocol_definition,
+      get_protocol_definition: glue.get_protocol_definition,
+      get_migration_complement: glue.get_migration_complement
     };
     const memory = initOutput.memory;
     if (!memory) {
@@ -168,30 +191,212 @@ function packMigrationMapping(mapping) {
     hyper_resolver: []
   });
 }
-function renameField(oldName, newName) {
-  return { type: "rename-field", old: oldName, new: newName };
-}
-function addField(name, vertexKind, defaultValue) {
-  return { type: "add-field", name, vertexKind, default: defaultValue };
-}
-function removeField(name) {
-  return { type: "remove-field", name };
-}
-function wrapInObject(fieldName) {
-  return { type: "wrap-in-object", fieldName };
-}
-function hoistField(host, field) {
-  return { type: "hoist-field", host, field };
-}
-function coerceType(fromKind, toKind) {
-  return { type: "coerce-type", fromKind, toKind };
-}
-function compose(first, second) {
-  return { type: "compose", first, second };
-}
-function pipeline(combinators) {
-  const [first, ...rest] = combinators;
-  return rest.reduce((acc, c) => compose(acc, c), first);
+class ProtolensChainHandle {
+  #handle;
+  #wasm;
+  constructor(handle, wasm) {
+    this.#handle = handle;
+    this.#wasm = wasm;
+  }
+  /** The underlying WASM handle. Internal use only. */
+  get _handle() {
+    return this.#handle;
+  }
+  /**
+   * Auto-generate a protolens chain between two schemas.
+   *
+   * @param schema1 - The source schema
+   * @param schema2 - The target schema
+   * @param wasm - The WASM module
+   * @returns A ProtolensChainHandle wrapping the generated chain
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  static autoGenerate(schema1, schema2, wasm) {
+    try {
+      const rawHandle = wasm.exports.auto_generate_protolens(schema1._handle.id, schema2._handle.id);
+      return new ProtolensChainHandle(createHandle(rawHandle, wasm), wasm);
+    } catch (error) {
+      throw new WasmError(
+        `auto_generate_protolens failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Instantiate this protolens chain against a concrete schema.
+   *
+   * @param schema - The schema to instantiate against
+   * @returns A LensHandle for the instantiated lens
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  instantiate(schema) {
+    try {
+      const rawHandle = this.#wasm.exports.instantiate_protolens(this.#handle.id, schema._handle.id);
+      return new LensHandle(createHandle(rawHandle, this.#wasm), this.#wasm);
+    } catch (error) {
+      throw new WasmError(
+        `instantiate_protolens failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Get the complement specification for instantiation against a schema.
+   *
+   * @param schema - The schema to check requirements against
+   * @returns The complement spec describing defaults and captured data
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  requirements(schema) {
+    try {
+      const bytes = this.#wasm.exports.protolens_complement_spec(this.#handle.id, schema._handle.id);
+      return unpackFromWasm(bytes);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_complement_spec failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Compose this chain with another protolens chain.
+   *
+   * @param other - The chain to compose with (applied second)
+   * @returns A new ProtolensChainHandle for the composed chain
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  compose(other) {
+    try {
+      const rawHandle = this.#wasm.exports.protolens_compose(this.#handle.id, other.#handle.id);
+      return new ProtolensChainHandle(createHandle(rawHandle, this.#wasm), this.#wasm);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_compose failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Serialize this chain to a JSON string.
+   *
+   * @returns A JSON representation of the chain
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  toJson() {
+    try {
+      const bytes = this.#wasm.exports.protolens_chain_to_json(this.#handle.id);
+      return new TextDecoder().decode(bytes);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_chain_to_json failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Deserialize a protolens chain from JSON via WASM.
+   *
+   * @param json - JSON string representing a protolens chain
+   * @param wasm - The WASM module
+   * @returns A ProtolensChainHandle wrapping the deserialized chain
+   * @throws {@link WasmError} if the WASM call fails or JSON is invalid
+   */
+  static fromJson(json, wasm) {
+    try {
+      const jsonBytes = new TextEncoder().encode(json);
+      const rawHandle = wasm.exports.protolens_from_json(jsonBytes);
+      return new ProtolensChainHandle(createHandle(rawHandle, wasm), wasm);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_from_json failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Fuse this chain into a single protolens step.
+   *
+   * Composes all steps into a single step with a composite complement,
+   * avoiding intermediate schema materialization.
+   *
+   * @returns A new ProtolensChainHandle containing the fused step
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  fuse() {
+    try {
+      const rawHandle = this.#wasm.exports.protolens_fuse(this.#handle.id);
+      return new ProtolensChainHandle(createHandle(rawHandle, this.#wasm), this.#wasm);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_fuse failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Check whether this chain can be instantiated at a given schema.
+   *
+   * @param schema - The schema to check against
+   * @returns An object with `applicable` boolean and `reasons` array
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  checkApplicability(schema) {
+    try {
+      const bytes = this.#wasm.exports.protolens_check_applicability(this.#handle.id, schema._handle.id);
+      return unpackFromWasm(bytes);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_check_applicability failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Lift this chain along a theory morphism.
+   *
+   * Given a morphism between theories, produces a new chain that operates
+   * on schemas of the codomain theory instead of the domain theory.
+   *
+   * @param morphismBytes - MessagePack-encoded theory morphism
+   * @returns A new ProtolensChainHandle for the lifted chain
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  lift(morphismBytes) {
+    try {
+      const rawHandle = this.#wasm.exports.protolens_lift(this.#handle.id, morphismBytes);
+      return new ProtolensChainHandle(createHandle(rawHandle, this.#wasm), this.#wasm);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_lift failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Apply this chain to a fleet of schemas.
+   *
+   * Checks applicability and instantiates the chain against each schema.
+   *
+   * @param schemas - Array of schema handles to apply the chain to
+   * @returns Fleet result with applied/skipped schema names and reasons
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  applyToFleet(schemas) {
+    try {
+      const handles = new Uint32Array(schemas.map((s) => s._handle.id));
+      const bytes = this.#wasm.exports.protolens_fleet(this.#handle.id, handles);
+      return unpackFromWasm(bytes);
+    } catch (error) {
+      throw new WasmError(
+        `protolens_fleet failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /** Release the underlying WASM resource. */
+  [Symbol.dispose]() {
+    this.#handle[Symbol.dispose]();
+  }
 }
 class LensHandle {
   #handle;
@@ -204,6 +409,53 @@ class LensHandle {
   get _handle() {
     return this.#handle;
   }
+  /**
+   * Auto-generate a lens between two schemas.
+   *
+   * Generates a protolens chain and immediately instantiates it.
+   *
+   * @param schema1 - The source schema
+   * @param schema2 - The target schema
+   * @param wasm - The WASM module
+   * @returns A LensHandle wrapping the generated lens
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  static autoGenerate(schema1, schema2, wasm) {
+    try {
+      const rawHandle = wasm.exports.auto_generate_protolens(schema1._handle.id, schema2._handle.id);
+      const chainHandle = createHandle(rawHandle, wasm);
+      const lensRaw = wasm.exports.instantiate_protolens(chainHandle.id, schema1._handle.id);
+      chainHandle[Symbol.dispose]();
+      const handle = createHandle(lensRaw, wasm);
+      return new LensHandle(handle, wasm);
+    } catch (error) {
+      throw new WasmError(
+        `autoGenerate failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Create a lens by instantiating a protolens chain against a schema.
+   *
+   * @param chain - The protolens chain to instantiate
+   * @param schema - The schema to instantiate against
+   * @param wasm - The WASM module
+   * @returns A LensHandle wrapping the instantiated lens
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  static fromChain(chain, schema, wasm) {
+    try {
+      const rawHandle = wasm.exports.instantiate_protolens(chain._handle.id, schema._handle.id);
+      const handle = createHandle(rawHandle, wasm);
+      return new LensHandle(handle, wasm);
+    } catch (error) {
+      throw new WasmError(
+        `fromChain failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
   /**
    * Forward projection: extract the view from a record.
    *
@@ -321,40 +573,74 @@ class LensHandle {
     this.#handle[Symbol.dispose]();
   }
 }
-function fromCombinators(schema, protocol, wasm, ...combinators) {
-  const wireCombs = combinators.map(combinatorToWire);
-  const combBytes = packToWasm(wireCombs);
-  try {
-    const rawHandle = wasm.exports.lens_from_combinators(
-      schema._handle.id,
-      protocol._handle.id,
-      combBytes
-    );
-    const handle = createHandle(rawHandle, wasm);
-    return new LensHandle(handle, wasm);
-  } catch (error) {
-    throw new WasmError(
-      `lens_from_combinators failed: ${error instanceof Error ? error.message : String(error)}`,
-      { cause: error }
-    );
+class SymmetricLensHandle {
+  #handle;
+  #wasm;
+  constructor(handle, wasm) {
+    this.#handle = handle;
+    this.#wasm = wasm;
   }
-}
-function combinatorToWire(combinator) {
-  switch (combinator.type) {
-    case "rename-field":
-      return { RenameField: { old: combinator.old, new: combinator.new } };
-    case "add-field":
-      return { AddField: { name: combinator.name, vertex_kind: combinator.vertexKind, default: combinator.default } };
-    case "remove-field":
-      return { RemoveField: { name: combinator.name } };
-    case "wrap-in-object":
-      return { WrapInObject: { field_name: combinator.fieldName } };
-    case "hoist-field":
-      return { HoistField: { host: combinator.host, field: combinator.field } };
-    case "coerce-type":
-      return { CoerceType: { from_kind: combinator.fromKind, to_kind: combinator.toKind } };
-    case "compose":
-      return { Compose: [combinatorToWire(combinator.first), combinatorToWire(combinator.second)] };
+  /**
+   * Create a symmetric lens between two schemas.
+   *
+   * @param schema1 - The left schema
+   * @param schema2 - The right schema
+   * @param wasm - The WASM module
+   * @returns A SymmetricLensHandle for bidirectional sync
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  static fromSchemas(schema1, schema2, wasm) {
+    try {
+      const rawHandle = wasm.exports.symmetric_lens_from_schemas(schema1._handle.id, schema2._handle.id);
+      return new SymmetricLensHandle(createHandle(rawHandle, wasm), wasm);
+    } catch (error) {
+      throw new WasmError(
+        `symmetric_lens_from_schemas failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Synchronize left view to right view.
+   *
+   * @param leftView - MessagePack-encoded left view data
+   * @param leftComplement - Opaque complement bytes from a prior sync
+   * @returns The synchronized right view and updated complement
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  syncLeftToRight(leftView, leftComplement) {
+    try {
+      const bytes = this.#wasm.exports.symmetric_lens_sync(this.#handle.id, leftView, leftComplement, 0);
+      return unpackFromWasm(bytes);
+    } catch (error) {
+      throw new WasmError(
+        `symmetric_lens_sync (left-to-right) failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Synchronize right view to left view.
+   *
+   * @param rightView - MessagePack-encoded right view data
+   * @param rightComplement - Opaque complement bytes from a prior sync
+   * @returns The synchronized left view and updated complement
+   * @throws {@link WasmError} if the WASM call fails
+   */
+  syncRightToLeft(rightView, rightComplement) {
+    try {
+      const bytes = this.#wasm.exports.symmetric_lens_sync(this.#handle.id, rightView, rightComplement, 1);
+      return unpackFromWasm(bytes);
+    } catch (error) {
+      throw new WasmError(
+        `symmetric_lens_sync (right-to-left) failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /** Release the underlying WASM resource. */
+  [Symbol.dispose]() {
+    this.#handle[Symbol.dispose]();
   }
 }
 class FullDiffReport {
@@ -1700,6 +1986,70 @@ class Repository {
     this.#handle[Symbol.dispose]();
   }
 }
+class DataSetHandle {
+  #handle;
+  #wasm;
+  constructor(handle, wasm) {
+    this.#handle = handle;
+    this.#wasm = wasm;
+  }
+  /** The WASM handle for this data set. Internal use only. */
+  get _handle() {
+    return this.#handle;
+  }
+  /** Store a data set from a JavaScript object, bound to a schema. */
+  static fromData(data, schema, wasm) {
+    const jsonBytes = new TextEncoder().encode(JSON.stringify(data));
+    const rawHandle = wasm.exports.store_dataset(schema._handle.id, jsonBytes);
+    return new DataSetHandle(createHandle(rawHandle, wasm), wasm);
+  }
+  /** Retrieve the data as MessagePack-encoded bytes. */
+  getData() {
+    const bytes = this.#wasm.exports.get_dataset(this.#handle.id);
+    return unpackFromWasm(bytes);
+  }
+  /** Migrate this data set forward to a new schema. */
+  migrateForward(srcSchema, tgtSchema) {
+    const bytes = this.#wasm.exports.migrate_dataset_forward(
+      this.#handle.id,
+      srcSchema._handle.id,
+      tgtSchema._handle.id
+    );
+    const result = unpackFromWasm(bytes);
+    const complementBytes = this.#wasm.exports.get_dataset(result.complement_handle);
+    this.#wasm.exports.free_handle(result.complement_handle);
+    return {
+      data: new DataSetHandle(createHandle(result.data_handle, this.#wasm), this.#wasm),
+      complement: new Uint8Array(complementBytes)
+    };
+  }
+  /** Migrate this data set backward using a complement. */
+  migrateBackward(complement, srcSchema, tgtSchema) {
+    const rawHandle = this.#wasm.exports.migrate_dataset_backward(
+      this.#handle.id,
+      complement,
+      srcSchema._handle.id,
+      tgtSchema._handle.id
+    );
+    return new DataSetHandle(createHandle(rawHandle, this.#wasm), this.#wasm);
+  }
+  /** Check if this data set is stale relative to a schema. */
+  isStale(schema) {
+    const bytes = this.#wasm.exports.check_dataset_staleness(
+      this.#handle.id,
+      schema._handle.id
+    );
+    const raw = unpackFromWasm(bytes);
+    return {
+      stale: raw.stale,
+      dataSchemaId: raw.data_schema_id,
+      targetSchemaId: raw.target_schema_id
+    };
+  }
+  [Symbol.dispose]() {
+    this.#handle[Symbol.dispose]();
+  }
+}
 class Panproto {
   #wasm;
   #protocols;
@@ -1929,6 +2279,76 @@ class Panproto {
   initRepo(protocolName) {
     return Repository.init(protocolName, this.#wasm);
   }
+  /**
+   * Convert data from one schema to another using an auto-generated lens.
+   *
+   * This is a convenience method that generates a protolens, applies the
+   * forward projection, and disposes the lens automatically.
+   *
+   * @param data - The input data (Uint8Array of MessagePack, or a plain object)
+   * @param opts - Conversion options specifying source and target schemas
+   * @returns The converted data
+   * @throws {@link WasmError} if lens generation or conversion fails
+   */
+  async convert(data, opts) {
+    const lens = LensHandle.autoGenerate(opts.from, opts.to, this.#wasm);
+    try {
+      const input = data instanceof Uint8Array ? data : packToWasm(data);
+      const result = lens.get(input);
+      return result.view;
+    } finally {
+      lens[Symbol.dispose]();
+    }
+  }
+  /**
+   * Create an auto-generated lens between two schemas.
+   *
+   * @param from - The source schema
+   * @param to - The target schema
+   * @returns A LensHandle for the generated lens
+   * @throws {@link WasmError} if lens generation fails
+   */
+  lens(from, to) {
+    return LensHandle.autoGenerate(from, to, this.#wasm);
+  }
+  /**
+   * Create a protolens chain between two schemas.
+   *
+   * The returned chain is schema-independent and can be instantiated
+   * against different concrete schemas.
+   *
+   * @param from - The source schema
+   * @param to - The target schema
+   * @returns A ProtolensChainHandle for the generated chain
+   * @throws {@link WasmError} if chain generation fails
+   */
+  protolensChain(from, to) {
+    return ProtolensChainHandle.autoGenerate(from, to, this.#wasm);
+  }
+  /**
+   * Store and track a data set against a schema.
+   *
+   * @param data - The data to store (array of records or a single object)
+   * @param schema - The schema this data conforms to
+   * @returns A disposable DataSetHandle
+   */
+  dataSet(data, schema) {
+    return DataSetHandle.fromData(data, schema, this.#wasm);
+  }
+  /**
+   * Migrate data forward between two schemas.
+   *
+   * Auto-generates a lens and migrates each record, returning the
+   * migrated data and a complement for backward migration.
+   *
+   * @param data - The data set to migrate
+   * @param from - The source schema
+   * @param to - The target schema
+   * @returns The migration result with new data and complement
+   */
+  migrateData(data, from, to) {
+    return data.migrateForward(from, to);
+  }
   /**
    * Release all WASM resources held by this instance.
    *
@@ -2062,12 +2482,24 @@ function migrateModel(sortInterp, morphism, wasm) {
   const resultBytes = wasm.exports.migrate_model(modelBytes, morphBytes);
   return unpackFromWasm(resultBytes);
 }
+function factorizeMorphism(morphismBytes, domain, codomain, wasm) {
+  try {
+    const bytes = wasm.exports.factorize_morphism(morphismBytes, domain._handle.id, codomain._handle.id);
+    return unpackFromWasm(bytes);
+  } catch (error) {
+    throw new WasmError(
+      `factorize_morphism failed: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
 export {
   ATPROTO_SPEC,
   BUILTIN_PROTOCOLS,
   BuiltSchema,
   CompatReport,
   CompiledMigration,
+  DataSetHandle,
   ExistenceCheckError,
   FullDiffReport,
   GRAPHQL_SPEC,
@@ -2082,28 +2514,22 @@ export {
   Panproto,
   PanprotoError,
   Protocol,
+  ProtolensChainHandle,
   Repository,
   SQL_SPEC,
   SchemaBuilder,
   SchemaValidationError,
+  SymmetricLensHandle,
   TheoryBuilder,
   TheoryHandle,
   ValidationResult,
   WasmError,
-  addField,
   checkMorphism,
-  coerceType,
   colimit,
-  compose,
   createTheory,
-  fromCombinators,
+  factorizeMorphism,
   getBuiltinProtocol,
   getProtocolNames,
-  hoistField,
-  migrateModel,
-  pipeline,
-  removeField,
-  renameField,
-  wrapInObject
+  migrateModel
 };
 //# sourceMappingURL=index.js.map