@panproto/core 0.12.0 → 0.13.0

package/dist/expr-parser.d.ts

@@ -0,0 +1,63 @@
+import { WasmModule, Expr, Literal } from './types.js';
+/**
+ * Parse expression source text into an AST node.
+ *
+ * Accepts Haskell-style expression syntax (lambdas, let bindings, pattern
+ * matches, record literals, etc.) and returns the corresponding {@link Expr}
+ * AST node.
+ *
+ * @param source - The expression source text
+ * @param wasm - The WASM module
+ * @returns The parsed expression AST
+ * @throws {@link WasmError} if the source text contains a syntax error
+ *
+ * @example
+ * ```typescript
+ * const expr = parseExpr('\\x -> x + 1', panproto._wasm);
+ * // => { type: 'lam', param: 'x', body: { type: 'builtin', op: 'Add', ... } }
+ * ```
+ */
+export declare function parseExpr(source: string, wasm: WasmModule): Expr;
+/**
+ * Evaluate an expression with an optional environment.
+ *
+ * Reduces the expression to a literal value. Free variables in the
+ * expression are resolved from the provided environment map.
+ *
+ * @param expr - The expression to evaluate
+ * @param env - Optional mapping of variable names to literal values
+ * @param wasm - The WASM module
+ * @returns The evaluated literal value
+ * @throws {@link WasmError} if evaluation fails (e.g., unbound variable, type error)
+ *
+ * @example
+ * ```typescript
+ * const expr = ExprBuilder.add(
+ *   ExprBuilder.var_('x'),
+ *   ExprBuilder.lit({ type: 'int', value: 1 }),
+ * );
+ * const result = evalExpr(expr, { x: { type: 'int', value: 41 } }, panproto._wasm);
+ * // => { type: 'int', value: 42 }
+ * ```
+ */
+export declare function evalExpr(expr: Expr, env: Record<string, Literal> | undefined, wasm: WasmModule): Literal;
+/**
+ * Parse and pretty-print an expression (round-trip formatting).
+ *
+ * Parses the source text and converts the resulting AST back to a
+ * canonical string representation. Useful for normalizing expression
+ * formatting.
+ *
+ * @param source - The expression source text
+ * @param wasm - The WASM module
+ * @returns The canonically formatted expression string
+ * @throws {@link WasmError} if the source text contains a syntax error
+ *
+ * @example
+ * ```typescript
+ * const formatted = formatExpr('\\x->x +  1', panproto._wasm);
+ * // => '\\x -> x + 1'
+ * ```
+ */
+export declare function formatExpr(source: string, wasm: WasmModule): string;
+//# sourceMappingURL=expr-parser.d.ts.map

package/dist/expr-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expr-parser.d.ts","sourceRoot":"","sources":["../src/expr-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAW,MAAM,YAAY,CAAC;AAIrE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACxC,IAAI,EAAE,UAAU,GACf,OAAO,CAYT;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAInE"}

package/dist/fiber.d.ts

@@ -0,0 +1,43 @@
+import { WasmModule } from './types.js';
+/** Node IDs in a fiber (preimage of migration at a target anchor). */
+export type Fiber = number[];
+/** Fiber decomposition: all fibers keyed by target anchor. */
+export type FiberDecomposition = Record<string, number[]>;
+/**
+ * Compute the fiber of a migration at a specific target anchor.
+ *
+ * Returns all source node IDs whose remapped anchor equals the target.
+ *
+ * @param instance - MessagePack-encoded instance bytes
+ * @param migration - MessagePack-encoded migration bytes
+ * @param targetAnchor - The target anchor to compute the fiber at
+ * @param wasm - The WASM module
+ * @returns Array of source node IDs in the fiber
+ * @throws {@link WasmError} if the fiber computation fails
+ *
+ * @example
+ * ```typescript
+ * const fiber = fiberAt(instanceBytes, migrationBytes, 'post', panproto._wasm);
+ * // => [0, 3, 7]
+ * ```
+ */
+export declare function fiberAt(instance: Uint8Array, migration: Uint8Array, targetAnchor: string, wasm: WasmModule): Fiber;
+/**
+ * Compute fibers for ALL target anchors simultaneously.
+ *
+ * Returns a map from target anchor to source node IDs.
+ *
+ * @param instance - MessagePack-encoded instance bytes
+ * @param migration - MessagePack-encoded migration bytes
+ * @param wasm - The WASM module
+ * @returns A record mapping each target anchor to its fiber node IDs
+ * @throws {@link WasmError} if the decomposition fails
+ *
+ * @example
+ * ```typescript
+ * const decomposition = fiberDecomposition(instanceBytes, migrationBytes, panproto._wasm);
+ * // => { post: [0, 3], comment: [1, 2, 5] }
+ * ```
+ */
+export declare function fiberDecomposition(instance: Uint8Array, migration: Uint8Array, wasm: WasmModule): FiberDecomposition;
+//# sourceMappingURL=fiber.d.ts.map

package/dist/fiber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fiber.d.ts","sourceRoot":"","sources":["../src/fiber.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,sEAAsE;AACtE,MAAM,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC;AAE7B,8DAA8D;AAC9D,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CACrB,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,UAAU,GACf,KAAK,CAUP;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,UAAU,EACrB,IAAI,EAAE,UAAU,GACf,kBAAkB,CAUpB"}

package/dist/graph.d.ts

@@ -0,0 +1,53 @@
+import { WasmModule } from './types.js';
+/** An edge in the lens graph. */
+export interface GraphEdge {
+    readonly source: string;
+    readonly target: string;
+    readonly chain: Uint8Array;
+}
+/** Result of a preferred path query. */
+export interface PreferredPath {
+    readonly cost: number;
+    readonly steps: string[];
+}
+/**
+ * Find the minimum-cost conversion path between two schemas.
+ *
+ * Returns null if no path exists.
+ *
+ * @param edges - The edges in the lens graph
+ * @param sourceSchema - The source schema identifier
+ * @param targetSchema - The target schema identifier
+ * @param wasm - The WASM module
+ * @returns The preferred path, or null if unreachable
+ * @throws {@link WasmError} if the computation fails for reasons other than no path
+ *
+ * @example
+ * ```typescript
+ * const path = preferredPath(edges, 'schema_v1', 'schema_v3', panproto._wasm);
+ * if (path) {
+ *   console.log(`Cost: ${path.cost}, Steps: ${path.steps}`);
+ * }
+ * ```
+ */
+export declare function preferredPath(edges: GraphEdge[], sourceSchema: string, targetSchema: string, wasm: WasmModule): PreferredPath | null;
+/**
+ * Get the distance (minimum conversion cost) between two schemas.
+ *
+ * Returns Infinity if no path exists.
+ *
+ * @param edges - The edges in the lens graph
+ * @param sourceSchema - The source schema identifier
+ * @param targetSchema - The target schema identifier
+ * @param wasm - The WASM module
+ * @returns The minimum conversion cost, or Infinity if unreachable
+ * @throws {@link WasmError} if the computation fails
+ *
+ * @example
+ * ```typescript
+ * const d = distance(edges, 'schema_v1', 'schema_v3', panproto._wasm);
+ * // => 2.0
+ * ```
+ */
+export declare function distance(edges: GraphEdge[], sourceSchema: string, targetSchema: string, wasm: WasmModule): number;
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,iCAAiC;AACjC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B;AAED,wCAAwC;AACxC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,EAAE,EAClB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,UAAU,GACf,aAAa,GAAG,IAAI,CAYtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,EAAE,EAClB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,UAAU,GACf,MAAM,CAUR"}

package/dist/hom.d.ts

@@ -0,0 +1,19 @@
+import { WasmModule } from './types.js';
+/**
+ * Construct the internal hom schema [S, T].
+ *
+ * Returns a schema whose instances represent lenses from S to T.
+ *
+ * @param sourceSchema - MessagePack-encoded source schema bytes
+ * @param targetSchema - MessagePack-encoded target schema bytes
+ * @param wasm - The WASM module
+ * @returns MessagePack-encoded hom schema bytes
+ * @throws {@link WasmError} if construction fails
+ *
+ * @example
+ * ```typescript
+ * const homSchema = polyHom(sourceBytes, targetBytes, panproto._wasm);
+ * ```
+ */
+export declare function polyHom(sourceSchema: Uint8Array, targetSchema: Uint8Array, wasm: WasmModule): Uint8Array;
+//# sourceMappingURL=hom.d.ts.map

package/dist/hom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hom.d.ts","sourceRoot":"","sources":["../src/hom.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CACrB,YAAY,EAAE,UAAU,EACxB,YAAY,EAAE,UAAU,EACxB,IAAI,EAAE,UAAU,GACf,UAAU,CASZ"}

package/dist/index.cjs

@@ -122,7 +122,16 @@ async function loadWasm(input) {
       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
+      get_migration_complement: glue.get_migration_complement,
+      parse_expr: glue.parse_expr,
+      eval_func_expr: glue.eval_func_expr,
+      execute_query: glue.execute_query,
+      // Phase 12: Fiber, hom, and graph
+      fiber_at: glue.fiber_at,
+      fiber_decomposition_wasm: glue.fiber_decomposition_wasm,
+      poly_hom: glue.poly_hom,
+      preferred_conversion_path: glue.preferred_conversion_path,
+      conversion_distance: glue.conversion_distance
     };
     const memory = initOutput.memory;
     if (!memory) {
@@ -2838,6 +2847,178 @@ class ExprBuilder {
     return ExprBuilder.builtin("Concat", a, b);
   }
 }
+function parseExpr(source, wasm) {
+  try {
+    const resultBytes = wasm.exports.parse_expr(source);
+    return unpackFromWasm(resultBytes);
+  } catch (error) {
+    throw new WasmError(
+      `Failed to parse expression: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function evalExpr(expr, env, wasm) {
+  try {
+    const exprBytes = packToWasm(expr);
+    const envBytes = packToWasm(env ?? {});
+    const resultBytes = wasm.exports.eval_func_expr(exprBytes, envBytes);
+    return unpackFromWasm(resultBytes);
+  } catch (error) {
+    throw new WasmError(
+      `Failed to evaluate expression: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function formatExpr(source, wasm) {
+  const expr = parseExpr(source, wasm);
+  return exprToString(expr);
+}
+function exprToString(expr) {
+  switch (expr.type) {
+    case "var":
+      return expr.name;
+    case "lit":
+      return literalToString(expr.value);
+    case "lam":
+      return `\\${expr.param} -> ${exprToString(expr.body)}`;
+    case "app":
+      return `(${exprToString(expr.func)} ${exprToString(expr.arg)})`;
+    case "let":
+      return `let ${expr.name} = ${exprToString(expr.value)} in ${exprToString(expr.body)}`;
+    case "field":
+      return `${exprToString(expr.expr)}.${expr.name}`;
+    case "record": {
+      const fields = expr.fields.map(([k, v]) => `${k} = ${exprToString(v)}`).join(", ");
+      return `{ ${fields} }`;
+    }
+    case "list": {
+      const items = expr.items.map(exprToString).join(", ");
+      return `[${items}]`;
+    }
+    case "index":
+      return `${exprToString(expr.expr)}[${exprToString(expr.index)}]`;
+    case "match": {
+      const arms = expr.arms.map(([pat, body]) => `${patternToString(pat)} -> ${exprToString(body)}`).join("; ");
+      return `match ${exprToString(expr.scrutinee)} { ${arms} }`;
+    }
+    case "builtin": {
+      const args = expr.args.map(exprToString).join(", ");
+      return `${expr.op}(${args})`;
+    }
+  }
+}
+function literalToString(lit) {
+  switch (lit.type) {
+    case "bool":
+      return String(lit.value);
+    case "int":
+      return String(lit.value);
+    case "float":
+      return String(lit.value);
+    case "str":
+      return JSON.stringify(lit.value);
+    case "bytes":
+      return `<bytes:${lit.value.length}>`;
+    case "null":
+      return "null";
+    case "record": {
+      const fields = lit.fields.map(([k, v]) => `${k} = ${literalToString(v)}`).join(", ");
+      return `{ ${fields} }`;
+    }
+    case "list": {
+      const items = lit.items.map(literalToString).join(", ");
+      return `[${items}]`;
+    }
+  }
+}
+function patternToString(pat) {
+  switch (pat.type) {
+    case "wildcard":
+      return "_";
+    case "var":
+      return pat.name;
+    case "lit":
+      return literalToString(pat.value);
+    case "record": {
+      const fields = pat.fields.map(([k, v]) => `${k} = ${patternToString(v)}`).join(", ");
+      return `{ ${fields} }`;
+    }
+    case "list": {
+      const items = pat.items.map(patternToString).join(", ");
+      return `[${items}]`;
+    }
+  }
+}
+function executeQuery(query, instance, wasm) {
+  try {
+    const queryBytes = packToWasm(query);
+    const resultBytes = wasm.exports.execute_query(queryBytes, instance._bytes);
+    return unpackFromWasm(resultBytes);
+  } catch (error) {
+    throw new WasmError(
+      `Failed to execute query: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function fiberAt(instance, migration, targetAnchor, wasm) {
+  try {
+    const resultBytes = wasm.exports.fiber_at(instance, migration, targetAnchor);
+    return unpackFromWasm(resultBytes);
+  } catch (error) {
+    throw new WasmError(
+      `Failed to compute fiber at "${targetAnchor}": ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function fiberDecomposition(instance, migration, wasm) {
+  try {
+    const resultBytes = wasm.exports.fiber_decomposition_wasm(instance, migration);
+    return unpackFromWasm(resultBytes);
+  } catch (error) {
+    throw new WasmError(
+      `Failed to compute fiber decomposition: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function polyHom(sourceSchema, targetSchema, wasm) {
+  try {
+    return wasm.exports.poly_hom(sourceSchema, targetSchema);
+  } catch (error) {
+    throw new WasmError(
+      `Failed to construct internal hom: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function preferredPath(edges, sourceSchema, targetSchema, wasm) {
+  try {
+    const graphBytes = packToWasm(edges);
+    const resultBytes = wasm.exports.preferred_conversion_path(
+      graphBytes,
+      sourceSchema,
+      targetSchema
+    );
+    return unpackFromWasm(resultBytes);
+  } catch {
+    return null;
+  }
+}
+function distance(edges, sourceSchema, targetSchema, wasm) {
+  try {
+    const graphBytes = packToWasm(edges);
+    return wasm.exports.conversion_distance(graphBytes, sourceSchema, targetSchema);
+  } catch (error) {
+    throw new WasmError(
+      `Failed to compute conversion distance: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
 function classifyOpticKind(chain, schema, _wasm) {
   const spec = chain.requirements(schema);
   const hasDefaults = spec.forwardDefaults.length > 0;
@@ -3122,8 +3303,17 @@ exports.WasmError = WasmError;
 exports.checkMorphism = checkMorphism;
 exports.colimit = colimit;
 exports.createTheory = createTheory;
+exports.distance = distance;
+exports.evalExpr = evalExpr;
+exports.executeQuery = executeQuery;
 exports.factorizeMorphism = factorizeMorphism;
+exports.fiberAt = fiberAt;
+exports.fiberDecomposition = fiberDecomposition;
+exports.formatExpr = formatExpr;
 exports.getBuiltinProtocol = getBuiltinProtocol;
 exports.getProtocolNames = getProtocolNames;
 exports.migrateModel = migrateModel;
+exports.parseExpr = parseExpr;
+exports.polyHom = polyHom;
+exports.preferredPath = preferredPath;
 //# sourceMappingURL=index.cjs.map