@sequenceholdings/managed-functions 0.1.1 → 0.3.0

package/README.md

@@ -1,15 +1,144 @@
 # `@sequenceholdings/managed-functions`
 
-`@sequenceholdings/managed-functions` is the TypeScript SDK for cache-enabled
-Managed Functions. Function code imports its context and cache types; Atlas and
-the local harness use its runtime helpers to construct the optional third
-handler argument. Ordinary two-argument handlers do not need this package.
+`@sequenceholdings/managed-functions` is the TypeScript SDK for Managed
+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.
 
 Managed Functions is a workflow-agnostic platform primitive. The runtime owns
 generic invocation, isolation, secrets, egress, caching, and observability;
 deployed functions own business logic. Primitive code must not identify a
-function consumer or branch on a function ID. See
-[Platform primitive boundaries](../../../docs/platform/platform-primitives.md).
+function consumer or branch on a function ID.
+
+## ORM as the invoking user
+
+Available in SDK **0.2.0 and later**. Install the SDK in the function package;
+the separate ORM authoring/compiler package is not needed in the deployed
+function. Copy the namespace's generated `operations.manifest.json` into that
+package, and keep it synchronized with the applied namespace version.
+
+```ts
+import type { Request, Response } from '@google-cloud/functions-framework'
+import { createFunctionOrmExecutor, FunctionOrmError } from '@sequenceholdings/managed-functions/orm'
+import manifest from './operations.manifest.json'
+
+// Nonsecret configuration: use your deployment's URL, never request input.
+const platformOrigin = 'https://your-environment.example.com'
+
+export async function handler(request: Request, response: Response) {
+  try {
+    // Create inside every invocation; never keep this executor in module state.
+    const orm = createFunctionOrmExecutor({
+      request,
+      baseUrl: platformOrigin,
+      namespace: 'directory',
+      manifest,
+    })
+    const profile = await orm.execute('GetMyProfile', {})
+    response.json(profile)
+  } catch (error) {
+    if (error instanceof FunctionOrmError) {
+      response.status(403).json({ error: error.code })
+      return
+    }
+    // Do not expose arbitrary exceptions or upstream response bodies.
+    response.status(502).json({ error: 'PROFILE_UNAVAILABLE' })
+  }
+}
+```
+
+The manifest declares the account and data scope. Replace these illustrative
+names with your provisioned account, namespace, relations and mutation names:
+
+```yaml
+service_account: directory-runtime
+capabilities:
+  data:
+    directory:
+      tables: [my_profile]
+      operations: [UpdateMyProfile]
+      query: false
+```
+
+The deployer needs permission to bind the service account. The human caller
+needs function invocation access plus the namespace runtime grants and operation
+capabilities. `tables` covers read relations, including linked selections and
+policy dependencies; `operations` contains persisted mutation names. These
+declarations restrict access; they do not grant the caller access. Apply matching
+namespace operations before deploying consumers. Open the Managed Functions guide at `/docs/managed-functions/overview` on
+your administrator-supplied platform URL for provisioning, grants and deployment.
+
+`createFunctionOrmExecutor({ request, baseUrl, namespace, manifest, fetchImpl? })`
+returns an isolated executor with `execute(operationName, variables?)`. It sends
+only registered operation hashes and variables. The optional `fetchImpl` is for
+testing or an application-owned transport; it must honor `redirect: 'error'`.
+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
+or body to choose where it sends a delegated credential.
+
+### Caller identity and trust boundary
+
+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.
+
+The platform must control ingress to the deployed handler. The helper consumes
+the request delivered by that gateway; it does **not** authenticate arbitrary
+HTTP requests or make a publicly reachable Functions Framework server safe.
+Its local metadata checks only reject an unsupported or expired invocation mode.
+The ORM server verifies the credential's signature and expiry, checks its
+declared scope, resolves the caller's current permissions, and enforces row
+policies on every operation. The helper exposes no decoded caller identity or
+capabilities for use as a separate authorization decision.
+
+`seq-studio functions dev` does not mint delegated user identity. A missing
+context there is expected; validate pure handler logic with supplied test
+executors and verify real caller permissions through a deployed invocation.
+Do not copy real invocation headers into fixtures or logs.
+
+### Errors and recovery
+
+`FunctionOrmError.code` is stable and safe to return without including the
+exception's stack or request headers:
+
+| Code | Recovery |
+| --- | --- |
+| `INVALID_CONFIGURATION` | Correct the trusted origin or fetch configuration. |
+| `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` | 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`
+or `OrmOperationError`, also exported from `/orm`. An `OrmOperationError` exposes
+`status` and `code`; handle those instead of returning its upstream message.
+A denied write is still denied; the helper supplies no permission
+fallback. A network error may follow a successful write: use application-level
+idempotency and inspect persisted results before retrying.
+
+## Opt-in cache
 
 Opt-in caching inside a Managed Function. When the manifest declares a `cache` block, the platform passes a process-reused `context` as the HTTP handler's third argument. Existing two-argument handlers keep working.
 

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

@@ -0,0 +1,65 @@
+declare class OrmClientError extends Error {
+    readonly status: number | null;
+    readonly name: string;
+    constructor(message: string, status?: number | null);
+}
+interface OperationErrorEntry {
+    readonly message: string;
+    readonly extensions?: {
+        readonly code?: string;
+    };
+}
+declare class OrmOperationError extends OrmClientError {
+    readonly code: string | null;
+    readonly errors: readonly OperationErrorEntry[];
+    readonly name = "OrmOperationError";
+    constructor(message: string, status: number | null, code: string | null, errors?: readonly OperationErrorEntry[]);
+}
+
+/** One entry of `operations.manifest.json` (generated by `orm generate`). */
+interface ManifestOperation {
+    readonly hash: string;
+    readonly kind: 'query' | 'mutation';
+    readonly requires: {
+        readonly capability?: string;
+        readonly role?: string;
+    } | null;
+}
+interface OperationsManifest {
+    readonly schemaHash: string;
+    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>, options?: OperationExecutionOptions): Promise<TData>;
+}
+
+type FunctionOrmErrorCode = 'INVALID_CONFIGURATION' | 'MISSING_CALLER_CONTEXT' | 'INVALID_CALLER_CONTEXT' | 'UNSUPPORTED_CALLER' | 'EXPIRED_CALLER_CONTEXT';
+declare class FunctionOrmError extends Error {
+    readonly code: FunctionOrmErrorCode;
+    readonly name = "FunctionOrmError";
+    constructor(code: FunctionOrmErrorCode, message: string);
+}
+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, fetchImpl, ...options }: FunctionOrmExecutorOptions): OperationExecutor;
+declare function createFunctionServiceOrmExecutor({ request, fetchImpl, ...options }: FunctionOrmExecutorOptions): OperationExecutor;
+
+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 };