llmz 0.9.0 → 1.0.2

package/dist/vm/drivers/node.d.ts

@@ -1,5 +1,5 @@
 import type { VMExecutionResult } from '../../types.js';
-import type { DriverExecutionContext, VMDriver } from '../types.js';
+import { type DriverExecutionContext, type VMDriver } from '../types.js';
 export declare class NodeDriver implements VMDriver {
     execute(ctx: DriverExecutionContext): Promise<VMExecutionResult>;
 }

package/dist/vm/drivers/quickjs.d.ts

@@ -1,6 +1,6 @@
 import { type QuickJSWASMModule } from 'quickjs-emscripten-core';
 import type { VMExecutionResult } from '../../types.js';
-import type { DriverExecutionContext, VMDriver } from '../types.js';
+import { type DriverExecutionContext, type VMDriver } from '../types.js';
 export declare const loadQuickJSModule: () => Promise<QuickJSWASMModule>;
 export declare class QuickJSDriver implements VMDriver {
     execute(ctx: DriverExecutionContext): Promise<VMExecutionResult>;

package/dist/vm/errors.d.ts

@@ -1,12 +1,12 @@
 import type { SourceMapConsumer } from 'source-map-js';
-import { SnapshotSignal, VMSignal } from '../errors.js';
+import { VMSignal } from '../errors.js';
 import type { Traces, VMExecutionResult } from '../types.js';
 export declare const handleErrorQuickJS: (err: Error, code: string, _consumer: SourceMapConsumer, traces: Traces.Trace[], variables: {
     [k: string]: any;
-}, lines_executed: Map<number, number>, userCodeStartLine: number, currentToolCall?: SnapshotSignal['toolCall'] | undefined) => VMExecutionResult;
-export declare const handleErrorNode: (err: Error, code: string, consumer: SourceMapConsumer, traces: Traces.Trace[], variables: {
+}, lines_executed: Map<number, number>, userCodeStartLine: number, recordTrace: (trace: Traces.Trace) => void) => VMExecutionResult;
+export declare const handleErrorNode: (err: Error, code: string, consumer: SourceMapConsumer, recordTrace: (trace: Traces.Trace) => void, variables: {
     [k: string]: () => any;
-}, _lines_executed: Map<number, number>, currentToolCall?: SnapshotSignal['toolCall'] | undefined) => never;
+}, _lines_executed: Map<number, number>, lastExecutedLine?: number) => never;
 export declare const handleCatch: (err: Error, traces: Traces.Trace[], variables: {
     [k: string]: () => any;
 }, lines_executed: Map<number, number>) => {

package/dist/vm/index.d.ts

@@ -2,9 +2,8 @@ import type { Trace, VMExecutionResult } from '../types.js';
 import type { VMContext } from './types.js';
 /**
  * Pre-warms the VM so the first execution doesn't pay the QuickJS WASM
- * instantiation cost. Fire-and-forget: called as soon as the model starts
- * writing a `■run` block, so the module loads while the code is still being
- * generated. No-op when the QuickJS driver is disabled or already loaded.
+ * instantiation cost. Call this while a native JavaScript tool call is being
+ * generated or before executing it. No-op when the driver is disabled or loaded.
  */
 export declare const warmupVM: () => void;
-export declare function runAsyncFunction(context: VMContext, code: string, traces?: Trace[], signal?: AbortSignal | null, timeout?: number): Promise<VMExecutionResult>;
+export declare function runAsyncFunction(context: VMContext, code: string, traces?: Trace[], signal?: AbortSignal | null, timeout?: number, memoryNames?: string[], recordTrace?: (trace: Trace) => void): Promise<VMExecutionResult>;

package/dist/vm/instrument.d.ts

@@ -1,11 +1,19 @@
 import type { SourceMapConsumer } from 'source-map-js';
 import { type CompiledCode } from '../compiler/index.js';
-import { SnapshotSignal } from '../errors.js';
-import type { Trace } from '../types.js';
-import { VMContext } from './types.js';
-export declare const NO_TRACKING: readonly [string, string, string, string, string];
+import { type VariableWrite } from '../session/memory.js';
+import type { Trace, VMExecutionResult } from '../types.js';
+import { type VMContext } from './types.js';
+export declare const NO_TRACKING: readonly [string, string, string, "__llmz_checkpoint", "__llmz_guard"];
 export type InstrumentationState = {
-    currentToolCall: SnapshotSignal['toolCall'] | undefined;
+    lastExecutedLine: number | undefined;
+    memoryNames: Set<string>;
+    variableWrites: VariableWrite[];
+    captureErrors: {
+        name: string;
+        reason: string;
+    }[];
 };
-export declare function instrumentContext(context: VMContext, transformed: CompiledCode, traces: Trace[], variables: Record<string, any>, lines_executed: Map<number, number>, consumer: SourceMapConsumer, userCodeStartLine: number): InstrumentationState;
+export declare function instrumentContext(context: VMContext, transformed: CompiledCode, recordTrace: (trace: Trace) => void, variables: Record<string, any>, lines_executed: Map<number, number>, consumer: SourceMapConsumer, userCodeStartLine: number, memoryNames?: string[]): InstrumentationState;
 export declare function findUserCodeStartLine(transformed: CompiledCode): number;
+/** Drop unsupported captures explicitly instead of presenting lossy placeholders as data. */
+export declare function finalizeMemoryCapture(result: VMExecutionResult, state: InstrumentationState): VMExecutionResult;

package/dist/vm/member-proxy.d.ts

@@ -0,0 +1,4 @@
+/** Host-only metadata lets QuickJS install the same missing-member behavior in its own realm. */
+export declare const MISSING_MEMBER: unique symbol;
+/** Only registered own members are callable; inherited Object methods are not API members. */
+export declare function withMissingMember<T extends object>(target: T, missing: (name: string) => never): T;

package/dist/vm/member-proxy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vm/memory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vm/return-semantics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vm/types.d.ts

@@ -1,19 +1,36 @@
 import type { SourceMapConsumer } from 'source-map-js';
 import type { CompiledCode } from '../compiler/index.js';
-import type { SnapshotSignal } from '../errors.js';
+import type { LLMzFailure, VMSignal } from '../errors.js';
 import type { Trace, VMExecutionResult } from '../types.js';
-export type VMContext = Record<string, any>;
+/** Host-only lifecycle hook; symbols are not copied into the generated program's globals. */
+export declare const VM_PROGRAM_COMPLETE: unique symbol;
+export declare const VM_TERMINATION: unique symbol;
+export declare const VM_CALL_SITE: unique symbol;
+export declare const VM_ON_ERROR: unique symbol;
+export type VMTermination = {
+    isTerminated(): boolean;
+    check(): void;
+    /** Host-owned signal; guest errors are never used to select a latched interruption. */
+    getSignal?(): VMSignal | undefined;
+};
+export type VMContext = Record<string, any> & {
+    [VM_CALL_SITE]?: () => number | undefined;
+    [VM_ON_ERROR]?: (error: LLMzFailure) => void;
+    [VM_PROGRAM_COMPLETE]?: () => void;
+    [VM_TERMINATION]?: VMTermination;
+};
 export type DriverExecutionContext = {
     transformed: CompiledCode;
+    memoryNames: string[];
     consumer: SourceMapConsumer;
     context: VMContext;
     traces: Trace[];
+    recordTrace: (trace: Trace) => void;
     signal: AbortSignal | null;
     timeout: number;
     code: string;
     lines_executed: Map<number, number>;
     variables: Record<string, any>;
-    currentToolCall: SnapshotSignal['toolCall'] | undefined;
 };
 export type VMDriver = {
     execute(ctx: DriverExecutionContext): Promise<VMExecutionResult>;