isolated-jsc 0.11.0 Proof Pack

import {
  createCapabilityAuditBuffer,
  runIsolated
} from "@absolutejs/isolated-jsc";

const audit = createCapabilityAuditBuffer({ maxEvents: 32 });

const { result, receipt } = await runIsolated("await tools('now'); 42", {
  policy: "tenant-script",
  globals: { tools: broker.reference },
  maxConsoleEntries: 4,
  maxConsoleBytes: 512,
  run: {
    ...audit.receiptOptions(),
    executionId: "exec_123",
    maxResultBytes: 16_384,
    purpose: "tenant-plugin",
    tenant: "tenant_acme",
  },
  withReceipt: true
});

receipt.capabilityCallsDropped;    // number of audit events not retained
receipt.capabilityCallsTruncated;  // true when the audit buffer overflowed
receipt.console.truncated;         // true when console capture overflowed
receipt.error?.code;               // machine-readable failure, when present
receipt.schemaVersion;             // 1 — stable receipt schema marker
receipt.outputBytes;               // estimated successful-result bytes

bun add @absolutejs/isolated-jsc
bunx @absolutejs/isolated-jsc

import {
  createCapabilityAuditBuffer,
  createCapabilityBroker,
  createIsolatedRunner,
  defineCapabilityTool
} from "@absolutejs/isolated-jsc";

type TenantContext = { id: string; plan: "free" | "pro" };
type OrderLookup = { id: string };
type Order = { id: string; status: string; totalUsd: number };

const audit = createCapabilityAuditBuffer<TenantContext>({ maxEvents: 100 });

const broker = createCapabilityBroker(
  {
    lookupOrder: defineCapabilityTool<
      OrderLookup,
      Order | null,
      TenantContext
    >({
      description: "Read one order by id for the current tenant",
      input: "OrderLookup",
      output: "Order | null",
      maxOutputBytes: 16_384,
      risk: "read-only",
      timeoutMs: 100,
      redactAuditInput: (input) => ({ id: (input as { id?: unknown }).id }),
      redactAuditOutput: (output) => {
        if (output === null) return null;
        const order = output as Order;
        return { id: order.id, status: order.status };
      },
      validateInput: (input) => {
        if (input === null || typeof input !== "object") {
          throw new Error("lookupOrder input must be an object");
        }
        const id = (input as { id?: unknown }).id;
        if (typeof id !== "string") {
          throw new Error("lookupOrder input requires a string id");
        }
        return { id };
      },
      handler: async ({ id }, tenant) => lookupOrderForTenant(tenant.id, id)
    })
  },
  {
    context: { id: "tenant_acme", plan: "pro" },
    onAudit: audit.onAudit
  }
);

const manifest = broker.manifest();

// Direct host calls infer Order | null from the tool map.
const order = await broker.call("lookupOrder", { id: "ord_123" });

const runner = createIsolatedRunner({
  policy: "ai-tool",
  pool: { maxSize: 64, idleMs: 60_000 },
});

await runner.precompile(
  "agentLookup",
  'async (tools, orderId) => await tools("lookupOrder", { id: orderId })',
  { key: "tenant_acme" }
);

const { result, metrics } = await runner.call(
  "agentLookup",
  'async (tools, orderId) => await tools("lookupOrder", { id: orderId })',
  [broker.reference, "ord_123"],
  {
    key: "tenant_acme",
    run: {
      ...audit.receiptOptions(),
      maxResultBytes: 16_384,
      purpose: "agent-tool-call",
      tenant: "tenant_acme"
    },
    withMetrics: true
  }
);

const stats = runner.stats();
await runner.dispose();