maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/qs/lib/stringify.js

@@ -36,6 +36,7 @@ var defaults = {
     charsetSentinel: false,
     commaRoundTrip: false,
     delimiter: '&',
+    depth: Infinity,
     encode: true,
     encodeDotInKeys: false,
     encoder: utils.encode,
@@ -80,10 +81,16 @@ var stringify = function stringify(
     formatter,
     encodeValuesOnly,
     charset,
-    sideChannel
+    sideChannel,
+    depth,
+    currentDepth
 ) {
     var obj = object;
 
+    if (currentDepth > depth) {
+        throw new RangeError('Input depth exceeded depth option of ' + depth);
+    }
+
     var tmpSc = sideChannel;
     var step = 0;
     var findFlag = false;
@@ -103,9 +110,9 @@ var stringify = function stringify(
         }
     }
 
-    if (typeof filter === 'function') {
-        obj = filter(prefix, obj);
-    } else if (obj instanceof Date) {
+    obj = typeof filter === 'function' ? filter(prefix, obj) : obj;
+
+    if (obj instanceof Date) {
         obj = serializeDate(obj);
     } else if (generateArrayPrefix === 'comma' && isArray(obj)) {
         obj = utils.maybeMap(obj, function (value) {
@@ -158,7 +165,7 @@ var stringify = function stringify(
 
     var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;
 
-    if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+    if (allowEmptyArrays && isArray(obj) && obj.length === 0 && Object.keys(obj).length === 0) {
         return adjustedPrefix + '[]';
     }
 
@@ -198,7 +205,9 @@ var stringify = function stringify(
             formatter,
             encodeValuesOnly,
             charset,
-            valueSideChannel
+            valueSideChannel,
+            depth,
+            currentDepth + 1
         ));
     }
 
@@ -265,6 +274,7 @@ var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
         charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
         commaRoundTrip: !!opts.commaRoundTrip,
         delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
+        depth: typeof opts.depth === 'number' ? opts.depth : defaults.depth,
         encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
         encodeDotInKeys: typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
         encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
@@ -324,9 +334,12 @@ module.exports = function (object, opts) {
         if (options.skipNulls && value === null) {
             continue;
         }
+
+        var encodedKey = options.encodeDotInKeys ? String(key).replace(/\./g, '%2E') : String(key);
+
         pushToArray(keys, stringify(
             value,
-            key,
+            encodedKey,
             generateArrayPrefix,
             commaRoundTrip,
             options.allowEmptyArrays,
@@ -342,7 +355,9 @@ module.exports = function (object, opts) {
             options.formatter,
             options.encodeValuesOnly,
             options.charset,
-            sideChannel
+            sideChannel,
+            options.depth,
+            0
         ));
     }
 

package/node_modules/qs/lib/utils.js

@@ -329,7 +329,7 @@ var isBuffer = function isBuffer(obj) {
         return false;
     }
 
-    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+    return !!(obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj));
 };
 
 var combine = function combine(a, b, arrayLimit, plainObjects, throwOnLimitExceeded) {
@@ -338,8 +338,15 @@ var combine = function combine(a, b, arrayLimit, plainObjects, throwOnLimitExcee
         if (throwOnLimitExceeded) {
             throw new RangeError('Array limit exceeded. Only ' + arrayLimit + ' element' + (arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
         }
-        var newIndex = getMaxIndex(a) + 1;
-        a[newIndex] = b;
+        // spread `b` one level, matching the `[].concat(a, b)` used below, so a
+        // collection appended to an already-overflowed object is flattened
+        // rather than nested under a single index
+        var bValues = isArray(b) ? b : [b];
+        var newIndex = getMaxIndex(a);
+        for (var i = 0; i < bValues.length; ++i) {
+            newIndex += 1;
+            a[newIndex] = bValues[i];
+        }
         setMaxIndex(a, newIndex);
         return a;
     }

package/node_modules/qs/package.json

@@ -2,7 +2,7 @@
     "name": "qs",
     "description": "A querystring parser that supports nesting and arrays, with a depth limit",
     "homepage": "https://github.com/ljharb/qs",
-    "version": "6.15.3",
+    "version": "6.16.0",
     "repository": {
         "type": "git",
         "url": "https://github.com/ljharb/qs.git"
@@ -37,14 +37,14 @@
     "devDependencies": {
         "@browserify/envify": "^6.0.0",
         "@browserify/uglifyify": "^6.0.0",
-        "@ljharb/eslint-config": "^22.2.3",
+        "@ljharb/eslint-config": "^22.2.4",
         "browserify": "^16.5.2",
         "bundle-collapser": "^1.4.0",
         "common-shakeify": "~1.0.0",
         "eclint": "^2.8.1",
         "es-value-fixtures": "^1.7.1",
-        "eslint": "^10.5.0",
-        "evalmd": "^0.0.19",
+        "eslint": "^10.9.0",
+        "evalmd": "^0.0.22",
         "for-each": "^0.3.5",
         "glob": "=10.3.7",
         "has-bigints": "^1.1.0",

package/node_modules/run/README.md

@@ -1,10 +1,8 @@
 # run
 
-`run` is a secure and efficient alternative to `eval` for coding agents with
-support for TypeScript.
-
-It is suitable for code-mode, code interpreter, or other patterns that require
-execution of untrusted JS or TS.
+`run` is an alternative to `eval` for coding agents, with support for
+TypeScript. Use it for code-mode, code interpreters, and other patterns that
+execute untrusted JS or TS.
 
 `run` executes JavaScript in a hardened QuickJS sandbox. Guest code starts with
 no access to Node.js, the filesystem, environment variables, modules, or the
@@ -20,7 +18,7 @@ repeating already invoked host functions.
 pnpm add run
 ```
 
-`run` requires Node.js 22.13 or newer.
+`run` supports Node.js 20.19 or newer and Bun.
 
 ## Run JavaScript
 
@@ -99,6 +97,94 @@ cannot cross the boundary. Returning one fails with a serialization error that
 includes its path when available. Keep capabilities in host functions and send
 data through their arguments and results.
 
+### Synchronous host functions
+
+Use `syncHostFunctions` when guest APIs must return before the next guest
+statement runs, such as filesystem compatibility methods. The host handler may
+still be asynchronous; `run` blocks only the invocation's worker while it
+settles and returns the serialized value directly to guest code.
+
+```ts
+const runner = createRunner({
+  syncHostFunctions: {
+    fs: {
+      readFile: async (path: string) => storage.read(path),
+      writeFile: async (path: string, value: string) =>
+        storage.write(path, value),
+    },
+  },
+});
+
+await runner.run({
+  source: `
+    fs.writeFile('/state', 'ready');
+    return fs.readFile('/state');
+  `,
+});
+```
+
+Synchronous host functions must settle to a serializable value and cannot
+interrupt a run. Their calls share `maxBridgeRequests` with ordinary host
+functions. Forward `getHostFunctionContext().abortSignal` to cancellable work;
+the signal is aborted on timeout or caller cancellation. The synchronous bridge
+is allocated only for runs that configure synchronous bindings or a module
+loader, is included in invocation memory admission, and is capped at 64 MiB.
+
+### Native ES modules
+
+Passing `moduleLoader` enables native module resolution. For compatibility,
+its presence evaluates `source` as an ES module unless `sourceType` is set
+explicitly. Module source supports static, cyclic, and dynamic imports:
+
+```ts
+await runner.run({
+  source: `import { value } from './value.js'; console.log(value);`,
+  moduleLoader: {
+    identity: 'workspace-v1',
+    normalize(specifier, importer) {
+      return resolveModuleSpecifier(specifier, importer);
+    },
+    load(specifier) {
+      return readModuleSource(specifier);
+    },
+  },
+});
+```
+
+Set `sourceType: 'function-body'` to retain top-level `await`, `return`, and a
+serialized run value while enabling native dynamic imports:
+
+```ts
+const result = await runner.run({
+  source: `
+    const { value } = await import('./value.js');
+    return value;
+  `,
+  sourceType: 'function-body',
+  moduleLoader,
+});
+```
+
+Set `sourceType: 'module'` to evaluate an entry module even when it has no
+imports and no module loader. Entry modules execute for their side effects and
+a completed module run has `value: undefined`; the module namespace is not
+serialized as the run result.
+
+`normalize` and `load` may be synchronous or asynchronous. Their results are
+bounded by the host-function bridge limits, and `SharedArrayBuffer` and
+`Atomics` remain unavailable to guest JavaScript. Module-backed runs can create
+and resume continuations when the loader has a non-empty stable `identity`.
+Loader failures are redacted before entering the sandbox.
+
+This allows modules to export functions and cyclic namespaces without turning
+those exports into result-serialization failures.
+
+Native Node type stripping is used when the runtime provides it, and Bun uses
+its native TypeScript transpiler. On Node 20, install the optional `typescript`
+peer dependency to enable runtime type stripping. Without that peer, JavaScript
+and already type-stripped input remain supported and QuickJS reports unsupported
+TypeScript syntax without exposing a host module-resolution error.
+
 ### Host function context
 
 Call `getHostFunctionContext()` when a host function needs runtime metadata,
@@ -279,14 +365,16 @@ verifying old tokens.
 ### Replay behavior
 
 A continuation contains a replay ledger. On resume, completed and rejected
-host functions are read from that ledger instead of being invoked again. The
-runtime replays the program and reinvokes only interrupted host functions that
-now have a resolution.
+asynchronous host functions, synchronous host functions, and module-loader
+operations are read from that ledger instead of being invoked again. The
+runtime reinvokes only interrupted host functions that now have a resolution;
+operations first reached after the recorded frontier dispatch normally.
 
-Replay verifies the source, host-function-name manifest, and complete
-serialized argument list for every host function call. Guest `Date`,
-`Date.now()`, and `Math.random()` remain deterministic across replay.
-Divergence is rejected before a mismatched host function executes.
+Replay verifies the source, asynchronous and synchronous host-function-name
+manifests, module-loader identity, and complete serialized argument list for
+every bridge call. Guest `Date`, `Date.now()`, and `Math.random()` remain
+deterministic across replay. Divergence is rejected before a mismatched
+integration executes.
 
 An interrupted host function itself is reinvoked. Call `interrupt()` before
 doing non-idempotent work. For writes that may be retried, use
@@ -312,7 +400,7 @@ const result = await run({
 });
 
 if (result.status === 'interrupted') {
-  // Present the complete batch to the user, then resolve every item together.
+  // Present the full batch to the user, then resolve every item together.
   await run({
     source,
     hostFunctions,
@@ -332,10 +420,10 @@ array.
 
 ### Scope and authorization
 
-Signed continuations are bound to the runner audience, transformed source,
-host-function-name manifest, and `continuationContext`. For tenant-, user-, or
-policy-scoped execution, provide authenticated context on both the initial run
-and every resume:
+Signed continuations are bound to the runner audience, source, asynchronous and
+synchronous host-function-name manifests, module-loader identity, and
+`continuationContext`. For tenant-, user-, or policy-scoped execution, provide
+authenticated context on both the initial run and every resume:
 
 ```ts
 await runner.run({
@@ -402,6 +490,9 @@ Runtime failures extend `RunError` and expose a stable `code`:
   host effects are safe to retry.
 - `RUN_PROTOCOL_ERROR` indicates malformed, tampered, expired, or divergent
   continuation state. Do not retry unchanged input.
+- `RUN_USER_SOURCE_ERROR` identifies uncaught guest evaluation failures, including
+  syntax errors and thrown values. Guest-authored `code` properties are replaced;
+  trusted host and runtime codes are preserved.
 - `RUN_HOST_FUNCTION_ERROR` comes from capability lookup or host function
   execution.
 - `RUN_BRIDGE_LIMIT`, `RUN_SOURCE_TOO_LARGE`, and serialization failures require

package/node_modules/run/THIRD_PARTY_NOTICES.md

@@ -1,16 +1,14 @@
 # Third-party notices
 
 `run` embeds the `devalue` serializer and a QuickJS WebAssembly runtime built by the
-[`quickjs-emscripten`](https://github.com/justjake/quickjs-emscripten) project.
+[`quickjs-wasi`](https://github.com/vercel-labs/quickjs-wasi) project.
 The following packages are used to build the published JavaScript and embedded
 WebAssembly artifact:
 
-| Package                                   | Version | License |
-| ----------------------------------------- | ------- | ------- |
-| `devalue`                                 | 5.8.2   | MIT     |
-| `quickjs-emscripten`                      | 0.32.0  | MIT     |
-| `quickjs-emscripten-core`                 | 0.32.0  | MIT     |
-| `@jitl/quickjs-wasmfile-release-asyncify` | 0.32.0  | MIT     |
+| Package        | Version | License |
+| -------------- | ------- | ------- |
+| `devalue`      | 5.8.2   | MIT     |
+| `quickjs-wasi` | 3.6.0   | MIT     |
 
 The release verification script rejects unreviewed changes to these embedded
 dependencies.
@@ -37,11 +35,11 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
-## quickjs-emscripten
+## quickjs-wasi
 
 The MIT License
 
-quickjs-emscripten copyright (c) 2019-2024 Jake Teton-Landis
+Copyright (c) quickjs-wasi contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -65,8 +63,10 @@ SOFTWARE.
 
 QuickJS Javascript Engine
 
-Copyright (c) 2017-2021 Fabrice Bellard
-Copyright (c) 2017-2021 Charlie Gordon
+Copyright (c) 2017-2026 Fabrice Bellard
+Copyright (c) 2017-2025 Charlie Gordon
+Copyright (c) 2023-2026 Ben Noordhuis
+Copyright (c) 2023-2026 Saúl Ibarra Corretgé
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/node_modules/run/dist/continuation-validation.js

@@ -112,12 +112,123 @@ const assertInterruptedEntry = (value, index, options) => {
     index
   );
 };
+const assertPlainJsonPayload = (value, maxBytes, index) => {
+  const bytes = Buffer.byteLength(value);
+  if (bytes > maxBytes) {
+    throw new RunProtocolError("Continuation ledger payload is too large.", {
+      bytes,
+      index,
+      maxBytes
+    });
+  }
+  try {
+    return parseJson(value);
+  } catch {
+    throw new RunProtocolError("Continuation module payload is invalid JSON.", {
+      index
+    });
+  }
+};
+const assertSynchronousEntry = (value, index, options) => {
+  if (!["sync-host", "module-normalize", "module-load"].includes(
+    String(value.bridgeKind)
+  ) || !["fulfilled", "rejected"].includes(String(value.status)) || (value.status === "fulfilled" ? !hasExactKeys(value, [
+    "bindingName",
+    "bridgeKind",
+    "inputJson",
+    "status",
+    "valueJson"
+  ]) || typeof value.valueJson !== "string" : !hasExactKeys(value, [
+    "bindingName",
+    "bridgeKind",
+    "error",
+    "inputJson",
+    "status"
+  ]) || !isSerializableError(value.error))) {
+    throw new RunProtocolError("Synchronous continuation entry is malformed.", {
+      index
+    });
+  }
+  if (value.bridgeKind === "sync-host") {
+    assertSerializedPayload(
+      value.inputJson,
+      options.maxHostFunctionInputBytes,
+      index
+    );
+    if (!Array.isArray(
+      parseJsonPayload(
+        value.inputJson,
+        "Continuation ledger arguments"
+      )
+    )) {
+      throw new RunProtocolError(
+        "Continuation ledger arguments must be encoded as an array.",
+        { index }
+      );
+    }
+    if (value.status === "fulfilled") {
+      assertSerializedPayload(
+        value.valueJson,
+        options.maxHostFunctionOutputBytes,
+        index
+      );
+    }
+  } else {
+    const input = assertPlainJsonPayload(
+      value.inputJson,
+      options.maxHostFunctionInputBytes,
+      index
+    );
+    const expectedLength = value.bridgeKind === "module-normalize" ? 2 : 1;
+    if (!Array.isArray(input) || input.length !== expectedLength || input.some((argument) => typeof argument !== "string")) {
+      throw new RunProtocolError(
+        "Continuation module arguments are malformed.",
+        { index }
+      );
+    }
+    if (value.status === "fulfilled") {
+      const output = assertPlainJsonPayload(
+        value.valueJson,
+        options.maxHostFunctionOutputBytes,
+        index
+      );
+      if (typeof output !== "string") {
+        throw new RunProtocolError(
+          "Continuation module result must be a string.",
+          { index }
+        );
+      }
+      if (value.bridgeKind === "module-load" && Buffer.byteLength(output) > options.maxSourceBytes) {
+        throw new RunProtocolError("Continuation module source is too large.", {
+          bytes: Buffer.byteLength(output),
+          index,
+          maxBytes: options.maxSourceBytes
+        });
+      }
+    }
+  }
+  if (value.status === "rejected") {
+    assertJsonValue(value.error);
+    const errorBytes = Buffer.byteLength(JSON.stringify(value.error));
+    if (errorBytes > options.maxHostFunctionOutputBytes) {
+      throw new RunProtocolError("Continuation error payload is too large.", {
+        bytes: errorBytes,
+        index,
+        maxBytes: options.maxHostFunctionOutputBytes
+      });
+    }
+  }
+};
 const assertLedgerEntry = (value, index, options) => {
   if (!isRecord(value) || typeof value.bindingName !== "string" || !/^[A-Za-z_$][\w$]*\.[^.]+$/u.test(value.bindingName) || Buffer.byteLength(value.bindingName) > 1024 || typeof value.inputJson !== "string" || !["fulfilled", "rejected", "interrupted"].includes(String(value.status))) {
     throw new RunProtocolError("Continuation ledger entry is malformed.", {
       index
     });
   }
+  if ("bridgeKind" in value) {
+    assertSynchronousEntry(value, index, options);
+    return;
+  }
   assertSerializedPayload(
     value.inputJson,
     options.maxHostFunctionInputBytes,
@@ -169,7 +280,11 @@ const validateLedger = (value, options) => {
     assertLedgerEntry(entry, index, options);
     totalBytes += Buffer.byteLength(entry.bindingName);
     totalBytes += Buffer.byteLength(entry.inputJson);
-    if (entry.status === "fulfilled") {
+    if ("bridgeKind" in entry) {
+      totalBytes += Buffer.byteLength(
+        entry.status === "fulfilled" ? entry.valueJson : JSON.stringify(entry.error)
+      );
+    } else if (entry.status === "fulfilled") {
       addSettledOrder(settledOrders, entry.settledOrder);
       totalBytes += Buffer.byteLength(entry.valueJson);
     } else if (entry.status === "rejected") {

package/node_modules/run/dist/errors.js

@@ -48,7 +48,13 @@ const sanitizeDetails = (value) => {
 };
 const safeErrorProperty = (error, property) => {
   try {
-    return error[property];
+    if (property === "code") {
+      return Reflect.get(error, "code");
+    }
+    if (property === "details") {
+      return Reflect.get(error, "details");
+    }
+    return error.stack;
   } catch {
     return void 0;
   }
@@ -141,7 +147,7 @@ const serializeError = (error) => {
 };
 const serializeBridgeErrorForGuest = (error, context) => {
   if (RunError.isInstance(error)) {
-    return compactError({
+    const serialized = compactError({
       code: boundedString(error.code, MAX_ERROR_CODE_BYTES, "RUN_ERROR"),
       message: boundedString(
         error.message,
@@ -150,6 +156,10 @@ const serializeBridgeErrorForGuest = (error, context) => {
       ),
       name: boundedString(error.name, MAX_ERROR_NAME_BYTES, "RunError")
     });
+    if (error instanceof RunSourceTooLargeError) {
+      serialized.details = error.details;
+    }
+    return serialized;
   }
   const fallback = context === "hostFunction" ? {
     code: "RUN_HOST_FUNCTION_ERROR",

package/node_modules/run/dist/host-function-invocation.js

@@ -137,6 +137,7 @@ const invokeHostFunction = async ({
   }
 };
 export {
-  invokeHostFunction
+  invokeHostFunction,
+  raceAgainstAbort
 };
 //# sourceMappingURL=host-function-invocation.js.map

package/node_modules/run/dist/run.js

@@ -1,6 +1,7 @@
 import { Buffer } from "node:buffer";
 import { runManaged } from "./runtime/manager.js";
 import { createSignedContinuationCodec } from "./continuation-codec.js";
+const isRunSourceType = (value) => value === "function-body" || value === "module";
 function missingContinuationCodec() {
   const message = "Continuation signing is not configured. Set RUN_CONTINUATION_SECRET or pass continuationSecret or continuationCodec to createRunner().";
   const error = () => {
@@ -85,8 +86,10 @@ const RESERVED_HOST_FUNCTION_NAMES = /* @__PURE__ */ new Set([
 ]);
 const HOST_FUNCTION_IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
 const assertEnumerableProperties = (value, label) => {
-  for (const name of Object.getOwnPropertyNames(value)) {
-    if (Object.getOwnPropertyDescriptor(value, name)?.enumerable !== true) {
+  for (const [name, descriptor] of Object.entries(
+    Object.getOwnPropertyDescriptors(value)
+  )) {
+    if (descriptor.enumerable !== true) {
       throw new TypeError(`${label(name)} must be enumerable.`);
     }
   }
@@ -146,6 +149,8 @@ const createRunner = (options = {}) => {
     secret: configuredSecret
   }));
   const continuationAudience = options.continuationAudience ?? "run";
+  const syncHostFunctions = options.syncHostFunctions ?? /* @__PURE__ */ Object.create(null);
+  const syncHostFunctionManifest = validateHostFunctions(syncHostFunctions);
   if (continuationAudience.length === 0 || Buffer.byteLength(continuationAudience) > 512) {
     throw new TypeError(
       "Runner continuationAudience must contain between 1 and 512 bytes."
@@ -153,18 +158,39 @@ const createRunner = (options = {}) => {
   }
   return {
     async run(input) {
-      const hostFunctions = input.hostFunctions ?? {};
+      const hostFunctions = input.hostFunctions ?? /* @__PURE__ */ Object.create(null);
       const hostFunctionManifest = validateHostFunctions(hostFunctions);
+      for (const namespace of syncHostFunctionManifest.keys()) {
+        if (hostFunctionManifest.has(namespace)) {
+          throw new TypeError(
+            `Host function namespace "${namespace}" cannot be both asynchronous and synchronous.`
+          );
+        }
+      }
+      if (input.sourceType !== void 0 && !isRunSourceType(input.sourceType)) {
+        throw new TypeError("Invalid sourceType configuration.");
+      }
+      if (input.moduleLoader !== void 0 && (typeof input.moduleLoader !== "object" || input.moduleLoader === null || typeof input.moduleLoader.load !== "function" || input.moduleLoader.normalize !== void 0 && typeof input.moduleLoader.normalize !== "function" || input.moduleLoader.identity !== void 0 && (typeof input.moduleLoader.identity !== "string" || Buffer.byteLength(input.moduleLoader.identity) > 512))) {
+        throw new TypeError("Invalid moduleLoader configuration.");
+      }
+      if (input.moduleLoader !== void 0 && input.continuation !== void 0 && (input.moduleLoader.identity === void 0 || input.moduleLoader.identity.length === 0)) {
+        throw new TypeError(
+          "A module loader must have a non-empty identity to resume a continuation."
+        );
+      }
       const value = await runManaged({
         ...input,
         continuationAudience,
         continuationCodec,
+        continuationEnabled: options.continuationCodec !== void 0 || configuredSecret !== void 0,
         hostFunctionManifest,
         hostFunctions,
         limits: {
           ...options.limits,
           ...input.limits
-        }
+        },
+        syncHostFunctionManifest,
+        syncHostFunctions
       });
       return value;
     }