@sequenceholdings/managed-functions 0.2.0 → 0.3.0

package/README.md

@@ -1,7 +1,8 @@
 # `@sequenceholdings/managed-functions`
 
 `@sequenceholdings/managed-functions` is the TypeScript SDK for Managed
-Functions. It provides caller-scoped ORM access and opt-in caching. The
+Functions. It provides caller-scoped ORM access, explicit service-account ORM
+access, and opt-in caching. The
 `/orm` import loads only the dependency-free ORM execution client, without
 initializing cache, storage, authentication or tracing libraries.
 
@@ -76,6 +77,13 @@ It never retries requests, follows redirects, reads credentials from a request
 body, substitutes a service token, or configures process-wide ORM state. Reuse
 within one handler invocation is supported; discard it when the handler returns.
 
+By default `numeric` and `bigint` values come back as JSON numbers, which
+JavaScript rounds past 15-17 significant digits. Pass
+`jsonScalars: 'lossless-v1'` to receive them as strings (`"250000.00"`); the
+executor then refuses any successful result the platform does not acknowledge
+in that form, with `OrmOperationError` code `LOSSLESS_TRANSPORT_UNAVAILABLE`.
+Send `numeric` and `bigint` variables as decimal strings in either mode.
+
 `baseUrl` must be an explicitly configured HTTPS origin, with no path, query,
 fragment or embedded credentials. Loopback HTTP is accepted for a local platform.
 There is no automatic environment URL: the helper never trusts a request header
@@ -86,6 +94,13 @@ or body to choose where it sends a delegated credential.
 This helper supports direct human invocations through the platform gateway.
 Scheduled/system-runner and service-account invocations fail closed. They do not
 silently become an attached service account or a recorded human initiator.
+
+`createFunctionServiceOrmExecutor` takes the same options and executes as the
+function's attached `service_account` instead. Use it for invocations with no
+human caller, such as a Lattice managed-function step, or where the function must
+deliberately act beyond its caller. The account's grants, capabilities and row
+policies apply, not the caller's, so enforce any per-user rule in the handler.
+The person who started the invocation stays on the credential for audit.
 No Function UUID, profile lookup, signing key, bearer token or claims decoder is
 required in application code.
 
@@ -111,9 +126,9 @@ exception's stack or request headers:
 | Code | Recovery |
 | --- | --- |
 | `INVALID_CONFIGURATION` | Correct the trusted origin or fetch configuration. |
-| `MISSING_CALLER_CONTEXT` | Declare the data binding and invoke through the platform as a signed-in user. |
+| `MISSING_CALLER_CONTEXT` | Declare the data binding. Caller mode: invoke through the platform as a signed-in user. Service mode: also declare `service_account` and invoke through the platform. |
 | `INVALID_CALLER_CONTEXT` | Verify that the request came through the supported platform runtime. |
-| `UNSUPPORTED_CALLER` | Use a direct human invocation; this helper has no service mode. |
+| `UNSUPPORTED_CALLER` | The invocation mode doesn't match the helper: use `createFunctionOrmExecutor` for a direct human invocation, and `createFunctionServiceOrmExecutor` for a system-runner (Lattice) invocation. |
 | `EXPIRED_CALLER_CONTEXT` | Begin a new invocation and construct a new executor. |
 
 Invalid manifests, unknown operations and ORM failures propagate `OrmClientError`

package/dist/capabilities.d.ts

@@ -0,0 +1,112 @@
+import type { ManagedFunctionLimitCatalog } from './limits';
+export declare const MANAGED_FUNCTION_CLI_PACKAGE = "@sequenceholdings/studio-cli";
+export declare const MANAGED_FUNCTION_SDK_PACKAGE = "@sequenceholdings/managed-functions";
+export declare const MANAGED_FUNCTION_CAPABILITIES: {
+    readonly tooling: {
+        readonly cli: {
+            readonly package: "@sequenceholdings/studio-cli";
+            readonly min: "0.4.0";
+        };
+        readonly sdk: {
+            readonly package: "@sequenceholdings/managed-functions";
+            readonly min: "0.3.0";
+        };
+    };
+    readonly features: {
+        readonly postgres_egress: {
+            readonly field: "egress";
+            readonly supported: true;
+            readonly limit: "a credentials-free postgres:// or postgresql:// URL on port 5432 with sslmode=verify-full";
+            readonly min_cli: "0.4.0";
+            readonly min_sdk: "0.3.0";
+        };
+        readonly http_headers: {
+            readonly field: "invocation.headers";
+            readonly max_bytes: number;
+            readonly limit: "32768 bytes (16384 bytes is Node's default and returns HTTP 431)";
+            readonly min_cli: "0.4.0";
+            readonly min_sdk: "0.3.0";
+        };
+        readonly invoke_timeout: {
+            readonly field: "limits.timeout_seconds";
+            readonly max_seconds: 3600;
+            readonly legacy_sdk_max_seconds: 300;
+            readonly limit: "1 to 3600 seconds; SDK clients older than the minimum stop at 300 seconds";
+            readonly min_cli: "0.4.0";
+            readonly min_sdk: "0.3.0";
+        };
+    };
+};
+export interface CapabilityTooling {
+    cli: {
+        package: string;
+        min: string;
+    };
+    sdk: {
+        package: string;
+        min: string;
+    };
+}
+export interface ManagedFunctionCapabilities {
+    tooling: CapabilityTooling;
+    features: {
+        postgres_egress?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        http_headers?: {
+            field: string;
+            max_bytes: number;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        invoke_timeout?: {
+            field: string;
+            max_seconds: number;
+            legacy_sdk_max_seconds: number;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+    };
+}
+export interface DeployedPolicy {
+    limits: ManagedFunctionLimitCatalog | null;
+    capabilities: ManagedFunctionCapabilities | null;
+}
+export interface PreflightManifest {
+    limits?: {
+        memory_mb?: number;
+        cpu?: number | 'auto';
+        concurrency?: number;
+        timeout_seconds?: number;
+        max_response_bytes?: number;
+        min_instances?: number;
+        max_instances?: number;
+        invoke_rate_per_minute?: number;
+    };
+    egress?: readonly string[];
+    capabilities?: {
+        data?: Readonly<Record<string, unknown>>;
+        storage?: unknown;
+    };
+}
+export interface PreflightIssue {
+    field: string;
+    limit: string;
+    requiredCli: string;
+    requiredSdk: string;
+    message: string;
+}
+export declare function versionIsOlder(installed: string, required: string): boolean;
+export declare function sdkVersionLowerBound(spec: string | undefined): string | null;
+export declare function sdkVersionFromPackageJson(raw: string): string | null;
+export declare function isPostgresEgress(entry: string): boolean;
+export declare function formatValidationDetail(issues: readonly {
+    path?: readonly PropertyKey[];
+    message?: string;
+}[]): string;

package/dist/capabilities.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANAGED_FUNCTION_CAPABILITIES = exports.MANAGED_FUNCTION_SDK_PACKAGE = exports.MANAGED_FUNCTION_CLI_PACKAGE = void 0;
+exports.versionIsOlder = versionIsOlder;
+exports.sdkVersionLowerBound = sdkVersionLowerBound;
+exports.sdkVersionFromPackageJson = sdkVersionFromPackageJson;
+exports.isPostgresEgress = isPostgresEgress;
+exports.formatValidationDetail = formatValidationDetail;
+const sdk_range_1 = require("./sdk-range");
+exports.MANAGED_FUNCTION_CLI_PACKAGE = '@sequenceholdings/studio-cli';
+exports.MANAGED_FUNCTION_SDK_PACKAGE = '@sequenceholdings/managed-functions';
+exports.MANAGED_FUNCTION_CAPABILITIES = {
+    tooling: {
+        cli: { package: exports.MANAGED_FUNCTION_CLI_PACKAGE, min: '0.4.0' },
+        sdk: { package: exports.MANAGED_FUNCTION_SDK_PACKAGE, min: '0.3.0' },
+    },
+    features: {
+        postgres_egress: {
+            field: 'egress',
+            supported: true,
+            limit: 'a credentials-free postgres:// or postgresql:// URL on port 5432 with sslmode=verify-full',
+            min_cli: '0.4.0',
+            min_sdk: '0.3.0',
+        },
+        http_headers: {
+            field: 'invocation.headers',
+            max_bytes: 32 * 1024,
+            limit: '32768 bytes (16384 bytes is Node\'s default and returns HTTP 431)',
+            min_cli: '0.4.0',
+            min_sdk: '0.3.0',
+        },
+        invoke_timeout: {
+            field: 'limits.timeout_seconds',
+            max_seconds: 3600,
+            legacy_sdk_max_seconds: 300,
+            limit: '1 to 3600 seconds; SDK clients older than the minimum stop at 300 seconds',
+            min_cli: '0.4.0',
+            min_sdk: '0.3.0',
+        },
+    },
+};
+function versionIsOlder(installed, required) {
+    const parse = (value) => value
+        .replace(/^v/, '')
+        .split('-')[0]
+        .split('.')
+        .map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    const left = parse(installed);
+    const right = parse(required);
+    for (let index = 0; index < 3; index += 1) {
+        const diff = (left[index] ?? 0) - (right[index] ?? 0);
+        if (diff !== 0)
+            return diff < 0;
+    }
+    return false;
+}
+function sdkVersionLowerBound(spec) {
+    return (0, sdk_range_1.concreteOrStaleSdkSpec)(spec, exports.MANAGED_FUNCTION_CAPABILITIES.features.invoke_timeout.min_sdk);
+}
+function sdkVersionFromPackageJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const dependencies = Reflect.get(parsed, 'dependencies');
+    const devDependencies = Reflect.get(parsed, 'devDependencies');
+    return sdkVersionLowerBound(dependencySpec(dependencies) ?? dependencySpec(devDependencies));
+}
+function dependencySpec(block) {
+    if (!block || typeof block !== 'object')
+        return undefined;
+    const value = Reflect.get(block, exports.MANAGED_FUNCTION_SDK_PACKAGE);
+    return typeof value === 'string' ? value : undefined;
+}
+function isPostgresEgress(entry) {
+    return /^postgres(ql)?:/i.test(entry.trim());
+}
+function formatValidationDetail(issues) {
+    const shown = issues.slice(0, 8).map((issue) => {
+        const path = (issue.path ?? [])
+            .map((part) => String(part))
+            .filter((part) => part.length > 0)
+            .join('.');
+        const message = issue.message?.trim() || 'invalid';
+        return path ? `${path}: ${message}` : message;
+    });
+    if (shown.length === 0)
+        return 'Validation error';
+    const extra = issues.length > shown.length ? ` (+${issues.length - shown.length} more)` : '';
+    return `Validation error: ${shown.join('; ')}${extra}`;
+}

package/dist/config.d.ts

@@ -2,6 +2,10 @@ export { shouldReportAtlasHttp } from './http-tracing';
 import { z } from 'zod';
 export { MANAGED_FUNCTION_LIMITS, MF_LIMITS_CAPS, MF_LIMITS_DEFAULTS, managedFunctionWorkloadLimitsSchema } from './limits';
 export type { ManagedFunctionLimitCatalog } from './limits';
+export { MANAGED_FUNCTION_CAPABILITIES, MANAGED_FUNCTION_CLI_PACKAGE, MANAGED_FUNCTION_SDK_PACKAGE, formatValidationDetail, isPostgresEgress, sdkVersionFromPackageJson, sdkVersionLowerBound, versionIsOlder, } from './capabilities';
+export type { DeployedPolicy, ManagedFunctionCapabilities, PreflightIssue, PreflightManifest, } from './capabilities';
+export { parseDeployedPolicy } from './deployed-policy';
+export { preflightManagedFunction } from './preflight';
 export declare const CACHE_MAX_TTL_SECONDS: 86400;
 export declare const cacheManifestSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cacheManifestSchema = exports.CACHE_MAX_TTL_SECONDS = exports.managedFunctionWorkloadLimitsSchema = exports.MF_LIMITS_DEFAULTS = exports.MF_LIMITS_CAPS = exports.MANAGED_FUNCTION_LIMITS = exports.shouldReportAtlasHttp = void 0;
+exports.cacheManifestSchema = exports.CACHE_MAX_TTL_SECONDS = exports.preflightManagedFunction = exports.parseDeployedPolicy = exports.versionIsOlder = exports.sdkVersionLowerBound = exports.sdkVersionFromPackageJson = exports.isPostgresEgress = exports.formatValidationDetail = exports.MANAGED_FUNCTION_SDK_PACKAGE = exports.MANAGED_FUNCTION_CLI_PACKAGE = exports.MANAGED_FUNCTION_CAPABILITIES = exports.managedFunctionWorkloadLimitsSchema = exports.MF_LIMITS_DEFAULTS = exports.MF_LIMITS_CAPS = exports.MANAGED_FUNCTION_LIMITS = exports.shouldReportAtlasHttp = void 0;
 exports.readCacheConfiguration = readCacheConfiguration;
 var http_tracing_1 = require("./http-tracing");
 Object.defineProperty(exports, "shouldReportAtlasHttp", { enumerable: true, get: function () { return http_tracing_1.shouldReportAtlasHttp; } });
@@ -11,6 +11,19 @@ Object.defineProperty(exports, "MANAGED_FUNCTION_LIMITS", { enumerable: true, ge
 Object.defineProperty(exports, "MF_LIMITS_CAPS", { enumerable: true, get: function () { return limits_2.MF_LIMITS_CAPS; } });
 Object.defineProperty(exports, "MF_LIMITS_DEFAULTS", { enumerable: true, get: function () { return limits_2.MF_LIMITS_DEFAULTS; } });
 Object.defineProperty(exports, "managedFunctionWorkloadLimitsSchema", { enumerable: true, get: function () { return limits_2.managedFunctionWorkloadLimitsSchema; } });
+var capabilities_1 = require("./capabilities");
+Object.defineProperty(exports, "MANAGED_FUNCTION_CAPABILITIES", { enumerable: true, get: function () { return capabilities_1.MANAGED_FUNCTION_CAPABILITIES; } });
+Object.defineProperty(exports, "MANAGED_FUNCTION_CLI_PACKAGE", { enumerable: true, get: function () { return capabilities_1.MANAGED_FUNCTION_CLI_PACKAGE; } });
+Object.defineProperty(exports, "MANAGED_FUNCTION_SDK_PACKAGE", { enumerable: true, get: function () { return capabilities_1.MANAGED_FUNCTION_SDK_PACKAGE; } });
+Object.defineProperty(exports, "formatValidationDetail", { enumerable: true, get: function () { return capabilities_1.formatValidationDetail; } });
+Object.defineProperty(exports, "isPostgresEgress", { enumerable: true, get: function () { return capabilities_1.isPostgresEgress; } });
+Object.defineProperty(exports, "sdkVersionFromPackageJson", { enumerable: true, get: function () { return capabilities_1.sdkVersionFromPackageJson; } });
+Object.defineProperty(exports, "sdkVersionLowerBound", { enumerable: true, get: function () { return capabilities_1.sdkVersionLowerBound; } });
+Object.defineProperty(exports, "versionIsOlder", { enumerable: true, get: function () { return capabilities_1.versionIsOlder; } });
+var deployed_policy_1 = require("./deployed-policy");
+Object.defineProperty(exports, "parseDeployedPolicy", { enumerable: true, get: function () { return deployed_policy_1.parseDeployedPolicy; } });
+var preflight_1 = require("./preflight");
+Object.defineProperty(exports, "preflightManagedFunction", { enumerable: true, get: function () { return preflight_1.preflightManagedFunction; } });
 const limits = limits_1.MANAGED_FUNCTION_LIMITS.cache;
 exports.CACHE_MAX_TTL_SECONDS = limits.default_ttl_seconds.max;
 exports.cacheManifestSchema = zod_1.z

package/dist/deployed-policy.d.ts

@@ -0,0 +1,2 @@
+import type { DeployedPolicy } from './capabilities';
+export declare function parseDeployedPolicy(body: unknown): DeployedPolicy;

package/dist/deployed-policy.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDeployedPolicy = parseDeployedPolicy;
+function isLimitCatalog(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const workload = Reflect.get(value, 'workload');
+    return !!workload && typeof workload === 'object';
+}
+function isCapabilities(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const tooling = Reflect.get(value, 'tooling');
+    const features = Reflect.get(value, 'features');
+    if (!tooling || typeof tooling !== 'object' || !features || typeof features !== 'object')
+        return false;
+    const cli = Reflect.get(tooling, 'cli');
+    const sdk = Reflect.get(tooling, 'sdk');
+    return hasPackageMin(cli) && hasPackageMin(sdk);
+}
+function hasPackageMin(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    return typeof Reflect.get(value, 'package') === 'string' && typeof Reflect.get(value, 'min') === 'string';
+}
+function parseDeployedPolicy(body) {
+    if (!body || typeof body !== 'object')
+        return { limits: null, capabilities: null };
+    const limits = Reflect.get(body, 'limits');
+    const capabilities = Reflect.get(body, 'capabilities');
+    return {
+        limits: isLimitCatalog(limits) ? limits : null,
+        capabilities: isCapabilities(capabilities) ? normalizeCapabilities(capabilities) : null,
+    };
+}
+function normalizeCapabilities(value) {
+    const features = value.features;
+    return {
+        tooling: value.tooling,
+        features: {
+            postgres_egress: normalizePostgres(features.postgres_egress),
+            http_headers: normalizeHeaders(features.http_headers),
+            invoke_timeout: normalizeTimeout(features.invoke_timeout),
+        },
+    };
+}
+function normalizePostgres(value) {
+    if (!value || typeof value.supported !== 'boolean' || typeof value.limit !== 'string')
+        return undefined;
+    if (typeof value.min_cli !== 'string' || typeof value.min_sdk !== 'string')
+        return undefined;
+    return {
+        field: typeof value.field === 'string' ? value.field : 'egress',
+        supported: value.supported,
+        limit: value.limit,
+        min_cli: value.min_cli,
+        min_sdk: value.min_sdk,
+    };
+}
+function normalizeHeaders(value) {
+    if (!value || typeof value.max_bytes !== 'number' || typeof value.limit !== 'string')
+        return undefined;
+    if (typeof value.min_cli !== 'string' || typeof value.min_sdk !== 'string')
+        return undefined;
+    return {
+        field: typeof value.field === 'string' ? value.field : 'invocation.headers',
+        max_bytes: value.max_bytes,
+        limit: value.limit,
+        min_cli: value.min_cli,
+        min_sdk: value.min_sdk,
+    };
+}
+function normalizeTimeout(value) {
+    if (!value || typeof value.limit !== 'string')
+        return undefined;
+    if (typeof value.max_seconds !== 'number' || typeof value.legacy_sdk_max_seconds !== 'number')
+        return undefined;
+    if (typeof value.min_cli !== 'string' || typeof value.min_sdk !== 'string')
+        return undefined;
+    return {
+        field: typeof value.field === 'string' ? value.field : 'limits.timeout_seconds',
+        max_seconds: value.max_seconds,
+        legacy_sdk_max_seconds: value.legacy_sdk_max_seconds,
+        limit: value.limit,
+        min_cli: value.min_cli,
+        min_sdk: value.min_sdk,
+    };
+}

package/dist/limits.d.ts

@@ -15,7 +15,7 @@ export declare const MANAGED_FUNCTION_LIMITS: {
         };
         readonly timeout_seconds: {
             readonly min: 1;
-            readonly max: 540;
+            readonly max: 3600;
             readonly default: 60;
             readonly unit: "seconds";
         };
@@ -44,9 +44,11 @@ export declare const MANAGED_FUNCTION_LIMITS: {
             readonly configurable: false;
         };
         readonly max_response_bytes: {
+            readonly min: 1;
             readonly max: number;
+            readonly default: number;
             readonly unit: "bytes";
-            readonly configurable: false;
+            readonly configurable: true;
         };
         readonly cpu: {
             readonly configurable: true;
@@ -126,6 +128,7 @@ export declare const managedFunctionWorkloadLimitsSchema: z.ZodPrefault<z.ZodObj
     cpu: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>>;
     concurrency: z.ZodDefault<z.ZodNumber>;
     timeout_seconds: z.ZodDefault<z.ZodNumber>;
+    max_response_bytes: z.ZodDefault<z.ZodNumber>;
     min_instances: z.ZodDefault<z.ZodNumber>;
     max_instances: z.ZodDefault<z.ZodNumber>;
     invoke_rate_per_minute: z.ZodDefault<z.ZodNumber>;
@@ -134,7 +137,7 @@ export declare const MF_LIMITS_CAPS: {
     readonly cpu: 2;
     readonly concurrency: 80;
     readonly memoryMb: 2048;
-    readonly timeoutSeconds: 540;
+    readonly timeoutSeconds: 3600;
     readonly maxInstances: 10;
     readonly invokeRatePerMinute: 600;
     readonly maxRequestBytes: number;

package/dist/limits.js

@@ -8,12 +8,18 @@ exports.MANAGED_FUNCTION_LIMITS = {
     },
     workload: {
         memory_mb: { min: 128, max: 2048, default: 256, unit: 'MiB per instance' },
-        timeout_seconds: { min: 1, max: 540, default: 60, unit: 'seconds' },
+        timeout_seconds: { min: 1, max: 3600, default: 60, unit: 'seconds' },
         min_instances: { min: 0, max: 10, default: 1, scope: 'Cannot exceed max_instances; warm instances incur idle charges' },
         max_instances: { min: 2, max: 10, default: 3, scope: 'Autoscaling ceiling; must allow at least two instances, and GCP may temporarily exceed it' },
         invoke_rate_per_minute: { min: 1, max: 600, default: 60, window_seconds: 60, scope: 'Per function across all Atlas replicas in the environment; Redis-backed fixed window. Redis unavailability rejects invocations (503); key loss resets the window' },
         max_request_bytes: { max: 1024 * 1024, unit: 'bytes', configurable: false },
-        max_response_bytes: { max: 4 * 1024 * 1024, unit: 'bytes', configurable: false },
+        max_response_bytes: {
+            min: 1,
+            max: 256 * 1024 * 1024,
+            default: 4 * 1024 * 1024,
+            unit: 'bytes',
+            configurable: true,
+        },
         cpu: {
             configurable: true, default: 'auto', min: 1, max: 2,
             min_memory_mb_for_multiple_cpus: 512,
@@ -51,6 +57,7 @@ exports.managedFunctionWorkloadLimitsSchema = zod_1.z.object({
     ]).default(workload.cpu.default),
     concurrency: integerLimit(workload.concurrency),
     timeout_seconds: integerLimit(workload.timeout_seconds),
+    max_response_bytes: integerLimit(workload.max_response_bytes),
     min_instances: integerLimit(workload.min_instances),
     max_instances: integerLimit(workload.max_instances),
     invoke_rate_per_minute: integerLimit(workload.invoke_rate_per_minute),
@@ -94,5 +101,5 @@ exports.MF_LIMITS_DEFAULTS = {
     maxInstances: workload.max_instances.default,
     invokeRatePerMinute: workload.invoke_rate_per_minute.default,
     maxRequestBytes: workload.max_request_bytes.max,
-    maxResponseBytes: workload.max_response_bytes.max,
+    maxResponseBytes: workload.max_response_bytes.default,
 };

package/dist/orm.d.ts

@@ -30,9 +30,13 @@ interface OperationsManifest {
     readonly opsHash?: string;
     readonly operations: Readonly<Record<string, ManifestOperation>>;
 }
+interface OperationExecutionOptions {
+    /** Reuse only when retrying the same logical mutation. */
+    idempotencyKey?: string;
+}
 interface OperationExecutor {
     /** Execute a manifest operation by name (or a raw `sha256:` hash). */
-    execute<TData = Record<string, unknown>>(op: string, variables?: Record<string, unknown>): Promise<TData>;
+    execute<TData = Record<string, unknown>>(op: string, variables?: Record<string, unknown>, options?: OperationExecutionOptions): Promise<TData>;
 }
 
 type FunctionOrmErrorCode = 'INVALID_CONFIGURATION' | 'MISSING_CALLER_CONTEXT' | 'INVALID_CALLER_CONTEXT' | 'UNSUPPORTED_CALLER' | 'EXPIRED_CALLER_CONTEXT';
@@ -44,13 +48,18 @@ declare class FunctionOrmError extends Error {
 interface FunctionOrmRequest {
     readonly headers: Pick<Headers, 'get'> | Readonly<Record<string, string | readonly string[] | undefined>>;
 }
+declare const ORM_JSON_SCALARS_HEADER = "x-sequence-orm-json-scalars";
+declare const ORM_LOSSLESS_JSON_SCALARS = "lossless-v1";
+type FunctionOrmJsonScalars = typeof ORM_LOSSLESS_JSON_SCALARS;
 interface FunctionOrmExecutorOptions {
     request: FunctionOrmRequest;
     baseUrl: string;
     namespace: string;
     manifest: unknown;
     fetchImpl?: typeof globalThis.fetch;
+    jsonScalars?: FunctionOrmJsonScalars;
 }
-declare function createFunctionOrmExecutor({ request, baseUrl, namespace, manifest, fetchImpl, }: FunctionOrmExecutorOptions): OperationExecutor;
+declare function createFunctionOrmExecutor({ request, fetchImpl, ...options }: FunctionOrmExecutorOptions): OperationExecutor;
+declare function createFunctionServiceOrmExecutor({ request, fetchImpl, ...options }: FunctionOrmExecutorOptions): OperationExecutor;
 
-export { FunctionOrmError, type FunctionOrmErrorCode, type FunctionOrmExecutorOptions, type FunctionOrmRequest, type OperationExecutor, type OperationsManifest, OrmClientError, OrmOperationError, createFunctionOrmExecutor };
+export { FunctionOrmError, type FunctionOrmErrorCode, type FunctionOrmExecutorOptions, type FunctionOrmJsonScalars, type FunctionOrmRequest, ORM_JSON_SCALARS_HEADER, ORM_LOSSLESS_JSON_SCALARS, type OperationExecutor, type OperationsManifest, OrmClientError, OrmOperationError, createFunctionOrmExecutor, createFunctionServiceOrmExecutor };