@synsema/wasm 0.6.48 → 0.6.50

package/README.md

@@ -112,15 +112,16 @@ an error). Works in `run`, `test`, `handle` and their `*Async` forms.
 ### Sealed receipts: `auditor` (v0.6.46)
 
 The engine accepts `auditor` (an X25519 public key in base64url, from `synsema receipt keygen`) and
-`sealed_bytes` (4096–16777216, default 65536) in a `run` request and returns the sealed receipt in
-`receipt`. In v0.6.46 `run()`/`runAsync()` do not pass `auditor` on; use the low-level API:
+`sealedBytes` (4096–16777216, default 65536) in `run()`/`runAsync()` and returns the sealed receipt
+in `receipt`. `test` and `handle` build no receipt: an `auditor` or `sealedBytes` there is an
+error (`auditor: only run seals a receipt`). Before v0.6.49 `run()`/`runAsync()` did not
+pass `auditor` on.
 
 ```js
-import { Synsema, instantiateSync, dispatchHostSync, offersOf } from "@synsema/wasm";
+import { Synsema } from "@synsema/wasm";
 const syn = await Synsema.loadNode();
-const host = { kv: { get: (ns, k) => null, set: (ns, k, v) => {} } };
-const inst = instantiateSync(syn.module, (kind, payload) => dispatchHostSync(host, kind, payload));
-const r = inst.call({ op: "run", source: code, filename: "app.syn", labels: true, auditor: AUDITOR_PUBLIC_KEY, host: offersOf(host) });
+await syn.ready();
+const r = syn.run(code, { filename: "app.syn", labels: true, auditor: AUDITOR_PUBLIC_KEY });
 r.receipt;   // the receipt object: write it as one JSON line for `synsema receipt verify` / `open`
 ```
 

package/index.d.ts

@@ -129,10 +129,21 @@ export interface RunOptions {
    * código escrito por un modelo, bajo un `ceiling` sin `declassify`, publique sólo lo que la
    * política de una persona publica. Los argumentos de una task de confianza son datos (una task
    * o una lambda entre ellos es error).
+   *
+   * v0.6.50 — `{ nombre: { source, templates: { "r.html": texto } } }` le da a la tool sus
+   * templates: dentro de ella `render`/`include`/`layout` resuelven sólo contra éstos.
    */
-  trusted?: Record<string, string>;
+  trusted?: Record<string, string | { source: string; templates?: Record<string, string> }>;
   /** El techo de los módulos de confianza, con la gramática de `ceiling` (`"stdout,declassify=clientes"`). */
   trustedCeiling?: string;
+  /**
+   * v0.6.46 — la pública X25519 (base64url, de `synsema receipt keygen`) del auditor que designa el
+   * host: `run`/`runAsync` devuelven el recibo sellado de la corrida en `RunResult.receipt` (lo de
+   * una rama privada va cifrado para el auditor). Sólo `run`; `test` y `handle` no arman recibo, y un `auditor` (o `sealedBytes`) ahí es un error.
+   */
+  auditor?: string;
+  /** Con `auditor`: los bytes del bloque sellado (4096–16777216, default 65536). */
+  sealedBytes?: number;
 }
 
 export interface AuditEntry {
@@ -142,6 +153,8 @@ export interface AuditEntry {
   reason: string;
   /** "program" (the program asked or called) or "runtime" (an ambient host grant, e.g. time/llm under a ceiling). */
   origin: "program" | "runtime";
+  /** v0.6.49 — dentro de una tool de confianza, `"trusted:<módulo>"` (como el `context` del audit nativo). */
+  context?: string;
 }
 
 export interface RunResult {
@@ -165,6 +178,12 @@ export interface RunResult {
    * del operador: el programa (y el cliente) ven en `errors` un texto fijo, porque cuál sitio cortó lo eligió el
    * dato privado. No se lo devuelvas al modelo ni al cliente. */
   operator_detail?: string;
+  /**
+   * Con `auditor`: el recibo sellado (un objeto). Escribilo como UNA línea JSON para
+   * `synsema receipt verify` / `synsema receipt open`. Sin recibo no hay salida: si no se pudo
+   * armar, `ok` es false y `errors` lo dice.
+   */
+  receipt?: Record<string, unknown>;
 }
 
 export interface TestResult {
@@ -212,6 +231,8 @@ export type ModuleSource = WebAssembly.Module | Uint8Array | ArrayBuffer | URL |
 export declare function readModule(src: ModuleSource): Promise<WebAssembly.Module>;
 export declare function offersOf(host?: Host): Record<string, boolean>;
 export declare function sleepSync(secs: number): void;
+/** Despacha una llamada del módulo (`kind`, `payload`) a los hooks síncronos de `host`; es lo que usan `run`/`test`/`handle`. */
+export declare function dispatchHostSync(host: Host | undefined, kind: string, payload: any): any;
 export declare function instantiate(
   module: WebAssembly.Module,
   hostCall: (kind: string, payload: any) => any,
@@ -234,6 +255,8 @@ export declare function instantiateSync(
 
 export declare class Synsema {
   constructor(module: WebAssembly.Module, opts?: LoadOptions);
+  /** El módulo compilado (para `instantiate`/`instantiateSync` con un despacho propio). */
+  readonly module: WebAssembly.Module;
   static load(src: ModuleSource, opts?: LoadOptions): Promise<Synsema>;
   /**
    * Node: carga el `synsema.wasm` que trae el paquete (sin resolver rutas; anda en Next, rutas

package/index.mjs

@@ -386,6 +386,10 @@ function requestOf(op, source, opts = {}) {
   // v0.6.46 (E3b): módulos de confianza del embebedor y su techo.
   if (opts.trusted) r.trusted = opts.trusted;
   if (opts.trustedCeiling) r.trusted_ceiling = opts.trustedCeiling;
+  // v0.6.49 (B1): el recibo sellado. Antes no se reenviaban y `run()` volvía sin `receipt`;
+  // `!= null` por lo mismo que los límites: un valor inválido llega al motor, que lo rechaza.
+  if (opts.auditor != null) r.auditor = opts.auditor;
+  if (opts.sealedBytes != null) r.sealed_bytes = opts.sealedBytes;
   return r;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synsema/wasm",
-  "version": "0.6.48",
+  "version": "0.6.50",
   "description": "Synsema — the programming language for AI agents — embedded as WebAssembly: run .syn programs inside browsers, Node/Bun/Deno and edge runtimes, lending them http/kv/llm from your app",
   "license": "MIT",
   "type": "module",