@sequenceholdings/managed-functions 0.4.4 → 0.5.1

package/README.md

@@ -1,5 +1,78 @@
 # `@sequenceholdings/managed-functions`
 
+## Unified invocation client (prepared 0.5.1)
+
+Create one client inside each invocation. The bootstrap snapshots only delivered
+platform credential headers; it never derives authority from a user payload or
+forwards the incoming bearer. Each domain initializes on its first call, so a
+directory-only invocation works without process or execution credentials.
+Unavailable domains fail closed with their existing typed errors before sending.
+Do not cache this client across invocations.
+
+```ts
+import { createFunctionPlatformClient } from "@sequenceholdings/managed-functions";
+
+const platform = createFunctionPlatformClient({ request, baseUrl: platformOrigin });
+const page = await platform.directory.listGroupMembers({ tenant, groupId, limit: 50 });
+const run = await platform.lattice.runs.get({ process, runId });
+const runs = await platform.lattice.runs.listPage({ process, limit: 50 });
+// These require a delivered Lattice execution credential with matching bindings.
+const execution = await platform.lattice.execution.getContext();
+const completion = await platform.lattice.execution.getHumanCompletion({ nodeId: "reminder" });
+```
+
+| Namespace | Authority and behavior |
+| --- | --- |
+| `directory.resolve/listGroupMembers` | Attached service account's dedicated directory credential; exact lookups and live roster pages |
+| `lattice.runs.get/listPage` | Dedicated process-read credential; manifest-declared processes and current Viewer grants |
+| `lattice.completedNodes.get` | Same process-read credential; exact completed run/process/node selection |
+| `lattice.getCompletedAgentReference` | Both process-read and separate agent-read credentials; bounded recovery reference |
+| `lattice.execution.getContext/getRunCreatorAccess/getHumanCompletion/getHumanCompletions/getParallelSnapshot` | Dedicated execution credential; verified invocation, execution and causal-receipt bindings |
+| `invocation.getInvocationContext/getCallerCapabilities` | Dedicated invocation-identity credential; actual caller and attached account remain separate |
+
+Directory and process reads use the shared platform contracts, clients and bounded
+transport. Specialized execution/human-proof and invocation-identity verification
+remain primitive adapters. Each request sends only its own credential; the
+completed-agent reference is the explicit two-credential exception. Local envelope
+and expiry checks never replace Atlas signature, active-invocation and live-grant
+checks. No operator administration or Lattice run-start capability is implied.
+Preserve empty pages with a non-null cursor and continue until null. Process pages
+reject mismatched selectors, duplicate runs, repeated/oversized cursors and excess
+rows; run summaries exclude authored state, outputs, metadata and error details.
+
+The same bootstrap covers the existing runtime domains:
+
+```ts
+const files = platform.storage.service.workspace(workspaceId);
+const members = await platform.directory.caller.resolveMembers({ groupId, subs });
+const response = await platform.agents.getCompletedRun({ agent, runId });
+const source = await platform.workflows.captureCompletedRun({ workflow, runId });
+```
+
+Caller/service Storage are explicit as `platform.storage.caller` and `.service`.
+Agent source/conversation verification lives in `platform.agents.evidence`;
+workflow verification in `platform.workflows.evidence`; monitoring publish/get/
+catalog in `.monitoring`; bounded actual-human Abrigo reads in `.abrigo.read`.
+All legacy factories remain compatibility adapters over shared domain contracts,
+selection/receipt validation and the same bounded HTTP engine. Credentials,
+receiver binding prechecks and runtime provenance bootstrap remain primitive-owned.
+ORM remains a separate primitive. Continue using generated operation clients and
+`@sequenceholdings/managed-functions/orm` for caller/service ORM execution; this
+bootstrap does not expose a data executor.
+
+For separately provisioned OAuth process dispatch, use the Platform server
+`createServiceAccountTokenProvider` and `createServicePlatformClient` bootstrap.
+It never uses an invocation credential as process-start authority. Provider
+Slack calls and application-owned business policies remain application-owned.
+
+Existing `createFunctionServiceDirectoryClient`,
+`createFunctionServiceProcessesClient`, `createFunctionLatticeClient` and
+`createFunctionInvocationClient` remain supported with the same error identities.
+This release is prepared and unpublished. Consumers pinned to older releases must
+keep their current factories until the coordinated Platform/Storage/primitive releases are
+published; do not update an app's source ahead of its resolvable lockfile.
+
+
 ## Group-member directory lookup (internal rollout)
 
 Functions can resolve selected members of existing Atlas groups to active,
@@ -131,13 +204,15 @@ or server rollout; the registered-operation workflow below remains supported.
 
 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.
+function. From SDK **0.5.0**, call operations by name: the platform resolves the
+name against the namespace's active version on every call, so the function
+keeps working when a schema change rehashes every operation, and it needs no
+copy of `operations.manifest.json`. A namespace re-apply that keeps the
+operation's name and variables needs no function redeploy.
 
 ```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'
@@ -149,7 +224,6 @@ export async function handler(request: Request, response: Response) {
       request,
       baseUrl: platformOrigin,
       namespace: 'directory',
-      manifest,
     })
     const profile = await orm.execute('GetMyProfile', {})
     response.json(profile)
@@ -164,11 +238,19 @@ export async function handler(request: Request, response: Response) {
 }
 ```
 
-The manifest declares the account and data scope. Replace these illustrative
-names with your provisioned account, namespace, relations and mutation names:
+The manifest declares the data scope. Acting on behalf of the caller (this
+example) needs no service account. To also act as the function itself
+(`createFunctionServiceOrmExecutor`, system-runner invocations), name a
+`service_account` you hold the actor role on. With a `service_account` named, the account acts in every declared namespace,
+unless you mark specific namespaces with `service: true` (which requires an
+account): then only those. The account's token and namespace floor cover only
+those service-mode namespaces.
+A deploy that needs an account and names none is refused with how to create or
+pick one.
+Replace these illustrative names with your namespace, relations and mutation
+names:
 
 ```yaml
-service_account: directory-runtime
 capabilities:
   data:
     directory:
@@ -177,7 +259,7 @@ capabilities:
       query: false
 ```
 
-The deployer needs permission to bind the service account. The human caller
+Binding a named account needs the deployer's permission to act as it. 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
@@ -185,9 +267,14 @@ declarations restrict access; they do not grant the caller access. Apply matchin
 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? })`
+`createFunctionOrmExecutor({ request, baseUrl, namespace, manifest?, operationSelection?, fetchImpl? })`
 returns an isolated executor with `execute(operationName, variables?)`. It sends
-only registered operation hashes and variables. The optional `fetchImpl` is for
+only an operation name (or hash) and variables, never document text.
+`operationSelection` defaults to `'name'`. A `manifest` is optional: functions
+that already pass one keep working, and it is used only as a one-time fallback
+when the platform predates name selectors. `operationSelection: 'hash'` pins the
+exact generated contract from `manifest` instead, and fails once a schema
+change retires that version. 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
@@ -838,8 +925,11 @@ do {
 
 The manifest permits at most 16 concrete group IDs. It does not grant access:
 the attached service account independently needs the tenant directory's Reader
-relation and the group's Member relation (direct membership or the group's Owner
-relation). Organization or application administration is not a fallback. The
+relation and the group's roster Reader relation. An explicit group Reader grant
+does not confer membership, group management, or access to resources shared with
+that group. Existing members and owners inherit roster Reader, so their existing
+access is preserved. New service accounts should receive Reader, not membership.
+Organization or application administration is not a runtime fallback. The
 actual attached account is checked on every page; the invoking human/system
 identity never supplies its grants. No user-mode directory API gains service mode.
 
@@ -854,3 +944,48 @@ Pagination scans membership positions, so a page may have zero members and a
 non-null `nextCursor`; continue until the cursor is null. Cursors expire after an
 hour and bind the tenant, group, function, immutable version and service account.
 They cannot be moved to another read scope. Access can be revoked between pages.
+
+Platform operators manage roster Reader grants separately from membership. Only
+verified human group owners or Sequence operators may grant/revoke them, and
+granting a service account additionally requires Actor on that account. Public
+and group-principal roster grants are not supported. The shared FGA model and
+Atlas host must both contain roster Reader support before granting it; older
+hosts still require membership. During host-first rollout, the new host checks
+existing Member access first and checks Reader only after a Member denial, so
+existing members remain usable while the model and client pins converge. Errors
+in authorization still fail closed. This is a host permission change, not a new SDK
+method or a reason to add a machine to a staff group.
+
+
+### Provisioning group roster access
+
+Platform SDK **0.1.0**, Managed Functions **0.5.1** and Studio CLI **0.8.2**
+prepare typed roster provisioning; these packages await separate publication.
+The host's existing group roster governance and Reader model must be available.
+An upgrade alone grants nothing.
+
+```sh
+seq-studio access grant group <group-id> --key roster-reader --principal-type user --principal-id 'service-account|<account-id>' -e <env>
+seq-studio access revoke group <group-id> --key roster-reader --principal-type user --principal-id 'service-account|<account-id>' -e <env>
+```
+
+The CLI uses `createOperatorPlatformClient` from `@sequenceholdings/platform/server`
+with its current control-plane login. `groups.rosterAccess.grant` and `revoke`
+send atomic deltas through the existing permission surface. They validate mutation
+counts, then read the complete direct-grant receipt and confirm the exact target
+and direct Reader state. They never replace other principals or remove membership.
+A failed or concurrent confirmation is surfaced without replaying the mutation.
+
+The shared transport owns origin validation, redirect refusal, deadlines, bounded
+responses and structured errors; the CLI supplies only its current session and
+host-scoped edge credentials. Atlas requires a verified human group owner or
+platform operator, plus service-account Actor standing for grants, and revalidates
+the target identity after writing. Revocation does not require Actor. An unavailable
+or unauthorized group fails closed. Directory Reader and the exact declared roster
+allowlist remain separate runtime gates.
+
+`createFunctionServiceDirectoryClient` retains its signature and dedicated header,
+but delegates to the shared directory client through an invocation transport.
+The legacy administrative export accepts a typed operator transport. No invocation
+credential becomes a governance credential and no SDK HTTP route becomes a direct
+public contract. See [the shared SDK architecture](../platform/README.md).

package/dist/abrigo-contract.d.ts

@@ -1,92 +1,2 @@
-import { z } from 'zod';
-export declare const FUNCTION_ABRIGO_READ_TOKEN_HEADER = "x-sequence-abrigo-read-token";
-export declare const FUNCTION_ABRIGO_READ_PATH = "/api/managed-functions/abrigo/read";
-export declare const FUNCTION_ABRIGO_READ_AUDIENCE = "atlas-managed-function-abrigo-read";
-export declare const ABRIGO_READ_MAX_RESPONSE_BYTES: number;
-export declare const ABRIGO_READ_TIMEOUT_MS = 30000;
-export declare const abrigoReadOperationSchema: z.ZodEnum<{
-    workflow: "workflow";
-    entity: "entity";
-    entityGroupSummary: "entityGroupSummary";
-    loanRoles: "loanRoles";
-    relatedLoanRoles: "relatedLoanRoles";
-    workflowLoanMappings: "workflowLoanMappings";
-    workflowDocuments: "workflowDocuments";
-    customerDocuments: "customerDocuments";
-    reviewWorkflow: "reviewWorkflow";
-    reviewWorkflowDocuments: "reviewWorkflowDocuments";
-    reviewWorkflowCustomerDocuments: "reviewWorkflowCustomerDocuments";
-}>;
-export type FunctionAbrigoReadOperation = z.infer<typeof abrigoReadOperationSchema>;
-export type AbrigoReadOperation = FunctionAbrigoReadOperation;
-export declare const functionAbrigoReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    operation: z.ZodLiteral<"workflow">;
-    workflowId: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"entity">;
-    entityId: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"entityGroupSummary">;
-    entityId: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"loanRoles">;
-    proposedLoanId: z.ZodNumber;
-    page: z.ZodNumber;
-    perPage: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"relatedLoanRoles">;
-    proposedLoanId: z.ZodNumber;
-    page: z.ZodNumber;
-    perPage: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"workflowLoanMappings">;
-    workflowId: z.ZodNumber;
-    page: z.ZodNumber;
-    perPage: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"workflowDocuments">;
-    workflowId: z.ZodNumber;
-    page: z.ZodNumber;
-    perPage: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"customerDocuments">;
-    customerId: z.ZodNumber;
-    page: z.ZodNumber;
-    perPage: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"reviewWorkflow">;
-    workflowId: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"reviewWorkflowDocuments">;
-    workflowId: z.ZodNumber;
-    page: z.ZodNumber;
-    perPage: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    operation: z.ZodLiteral<"reviewWorkflowCustomerDocuments">;
-    workflowId: z.ZodNumber;
-    page: z.ZodNumber;
-    perPage: z.ZodNumber;
-}, z.core.$strict>], "operation">;
-export type FunctionAbrigoReadRequest = z.infer<typeof functionAbrigoReadRequestSchema>;
-export declare const functionAbrigoReadScopesSchema: z.ZodObject<{
-    read: z.ZodArray<z.ZodEnum<{
-        workflow: "workflow";
-        entity: "entity";
-        entityGroupSummary: "entityGroupSummary";
-        loanRoles: "loanRoles";
-        relatedLoanRoles: "relatedLoanRoles";
-        workflowLoanMappings: "workflowLoanMappings";
-        workflowDocuments: "workflowDocuments";
-        customerDocuments: "customerDocuments";
-        reviewWorkflow: "reviewWorkflow";
-        reviewWorkflowDocuments: "reviewWorkflowDocuments";
-        reviewWorkflowCustomerDocuments: "reviewWorkflowCustomerDocuments";
-    }>>;
-}, z.core.$strict>;
-export declare function readFunctionAbrigoReadScopes(manifest: unknown): FunctionAbrigoReadOperation[];
-export declare class FunctionAbrigoReadError extends Error {
-    readonly status: number;
-    readonly code: string;
-    readonly name = "FunctionAbrigoReadError";
-    constructor(status: number, code: string, message: string);
-}
+export { FUNCTION_ABRIGO_READ_TOKEN_HEADER, FUNCTION_ABRIGO_READ_PATH, FUNCTION_ABRIGO_READ_AUDIENCE, ABRIGO_READ_MAX_RESPONSE_BYTES, ABRIGO_READ_TIMEOUT_MS, abrigoReadOperationSchema, functionAbrigoReadRequestSchema, functionAbrigoReadScopesSchema, readFunctionAbrigoReadScopes, FunctionAbrigoReadError, } from "@sequenceholdings/platform/contracts";
+export type { FunctionAbrigoReadOperation, AbrigoReadOperation, FunctionAbrigoReadRequest, } from "@sequenceholdings/platform/contracts";

package/dist/abrigo-contract.js

@@ -1,55 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionAbrigoReadError = exports.functionAbrigoReadScopesSchema = exports.functionAbrigoReadRequestSchema = exports.abrigoReadOperationSchema = exports.ABRIGO_READ_TIMEOUT_MS = exports.ABRIGO_READ_MAX_RESPONSE_BYTES = exports.FUNCTION_ABRIGO_READ_AUDIENCE = exports.FUNCTION_ABRIGO_READ_PATH = exports.FUNCTION_ABRIGO_READ_TOKEN_HEADER = void 0;
-exports.readFunctionAbrigoReadScopes = readFunctionAbrigoReadScopes;
-const zod_1 = require("zod");
-exports.FUNCTION_ABRIGO_READ_TOKEN_HEADER = 'x-sequence-abrigo-read-token';
-exports.FUNCTION_ABRIGO_READ_PATH = '/api/managed-functions/abrigo/read';
-exports.FUNCTION_ABRIGO_READ_AUDIENCE = 'atlas-managed-function-abrigo-read';
-exports.ABRIGO_READ_MAX_RESPONSE_BYTES = 1024 * 1024;
-exports.ABRIGO_READ_TIMEOUT_MS = 30_000;
-exports.abrigoReadOperationSchema = zod_1.z.enum([
-    'workflow', 'entity', 'entityGroupSummary', 'loanRoles', 'relatedLoanRoles',
-    'workflowLoanMappings', 'workflowDocuments', 'customerDocuments',
-    'reviewWorkflow', 'reviewWorkflowDocuments', 'reviewWorkflowCustomerDocuments',
-]);
-const id = zod_1.z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-const page = zod_1.z.number().int().min(1).max(100);
-const perPage = zod_1.z.number().int().min(1).max(500);
-exports.functionAbrigoReadRequestSchema = zod_1.z.discriminatedUnion('operation', [
-    zod_1.z.strictObject({ operation: zod_1.z.literal('workflow'), workflowId: id }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('entity'), entityId: id }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('entityGroupSummary'), entityId: id }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('loanRoles'), proposedLoanId: id, page, perPage }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('relatedLoanRoles'), proposedLoanId: id, page, perPage }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('workflowLoanMappings'), workflowId: id, page, perPage }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('workflowDocuments'), workflowId: id, page, perPage }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('customerDocuments'), customerId: id, page, perPage }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('reviewWorkflow'), workflowId: id }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('reviewWorkflowDocuments'), workflowId: id, page, perPage }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('reviewWorkflowCustomerDocuments'), workflowId: id, page, perPage }),
-]);
-exports.functionAbrigoReadScopesSchema = zod_1.z.strictObject({
-    read: zod_1.z.array(exports.abrigoReadOperationSchema).min(1).max(11)
-        .refine((operations) => new Set(operations).size === operations.length, 'Abrigo read operations must be distinct'),
-});
-function readFunctionAbrigoReadScopes(manifest) {
-    if (typeof manifest !== 'object' || manifest === null)
-        return [];
-    const capabilities = Reflect.get(manifest, 'capabilities');
-    if (typeof capabilities !== 'object' || capabilities === null)
-        return [];
-    const abrigo = Reflect.get(capabilities, 'abrigo');
-    return abrigo === undefined ? [] : exports.functionAbrigoReadScopesSchema.parse(abrigo).read;
-}
-class FunctionAbrigoReadError extends Error {
-    status;
-    code;
-    name = 'FunctionAbrigoReadError';
-    constructor(status, code, message) {
-        super(message);
-        this.status = status;
-        this.code = code;
-    }
-}
-exports.FunctionAbrigoReadError = FunctionAbrigoReadError;
+exports.FunctionAbrigoReadError = exports.readFunctionAbrigoReadScopes = exports.functionAbrigoReadScopesSchema = exports.functionAbrigoReadRequestSchema = exports.abrigoReadOperationSchema = exports.ABRIGO_READ_TIMEOUT_MS = exports.ABRIGO_READ_MAX_RESPONSE_BYTES = exports.FUNCTION_ABRIGO_READ_AUDIENCE = exports.FUNCTION_ABRIGO_READ_PATH = exports.FUNCTION_ABRIGO_READ_TOKEN_HEADER = void 0;
+var contracts_1 = require("@sequenceholdings/platform/contracts");
+Object.defineProperty(exports, "FUNCTION_ABRIGO_READ_TOKEN_HEADER", { enumerable: true, get: function () { return contracts_1.FUNCTION_ABRIGO_READ_TOKEN_HEADER; } });
+Object.defineProperty(exports, "FUNCTION_ABRIGO_READ_PATH", { enumerable: true, get: function () { return contracts_1.FUNCTION_ABRIGO_READ_PATH; } });
+Object.defineProperty(exports, "FUNCTION_ABRIGO_READ_AUDIENCE", { enumerable: true, get: function () { return contracts_1.FUNCTION_ABRIGO_READ_AUDIENCE; } });
+Object.defineProperty(exports, "ABRIGO_READ_MAX_RESPONSE_BYTES", { enumerable: true, get: function () { return contracts_1.ABRIGO_READ_MAX_RESPONSE_BYTES; } });
+Object.defineProperty(exports, "ABRIGO_READ_TIMEOUT_MS", { enumerable: true, get: function () { return contracts_1.ABRIGO_READ_TIMEOUT_MS; } });
+Object.defineProperty(exports, "abrigoReadOperationSchema", { enumerable: true, get: function () { return contracts_1.abrigoReadOperationSchema; } });
+Object.defineProperty(exports, "functionAbrigoReadRequestSchema", { enumerable: true, get: function () { return contracts_1.functionAbrigoReadRequestSchema; } });
+Object.defineProperty(exports, "functionAbrigoReadScopesSchema", { enumerable: true, get: function () { return contracts_1.functionAbrigoReadScopesSchema; } });
+Object.defineProperty(exports, "readFunctionAbrigoReadScopes", { enumerable: true, get: function () { return contracts_1.readFunctionAbrigoReadScopes; } });
+Object.defineProperty(exports, "FunctionAbrigoReadError", { enumerable: true, get: function () { return contracts_1.FunctionAbrigoReadError; } });

package/dist/abrigo-response.d.ts

@@ -1,6 +1 @@
-import type { JsonValue } from './cache';
-import { type FunctionAbrigoReadRequest } from './abrigo-contract';
-export declare function validateAbrigoReviewResponse({ query, body }: {
-    query: FunctionAbrigoReadRequest;
-    body: JsonValue;
-}): void;
+export { validateAbrigoReviewResponse } from "@sequenceholdings/platform/adapters";

package/dist/abrigo-response.js

@@ -1,27 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAbrigoReviewResponse = validateAbrigoReviewResponse;
-const zod_1 = require("zod");
-const abrigo_contract_1 = require("./abrigo-contract");
-const positiveId = zod_1.z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-const reviewWorkflowSchema = zod_1.z.strictObject({ id: positiveId, customerId: positiveId });
-const reviewDocumentsSchema = zod_1.z.object({ items: zod_1.z.array(zod_1.z.unknown()).max(500) }).passthrough();
-const reviewCustomerDocumentsSchema = reviewDocumentsSchema.extend({ workflowId: positiveId, customerId: positiveId });
-function validateAbrigoReviewResponse({ query, body }) {
-    const invalid = () => new abrigo_contract_1.FunctionAbrigoReadError(502, 'malformed_response', 'Atlas returned an invalid workflow document review response');
-    if (query.operation === 'reviewWorkflow') {
-        const parsed = reviewWorkflowSchema.safeParse(body);
-        if (!parsed.success || parsed.data.id !== query.workflowId)
-            throw invalid();
-    }
-    else if (query.operation === 'reviewWorkflowDocuments') {
-        const parsed = reviewDocumentsSchema.safeParse(body);
-        if (!parsed.success || parsed.data.items.length > query.perPage)
-            throw invalid();
-    }
-    else if (query.operation === 'reviewWorkflowCustomerDocuments') {
-        const parsed = reviewCustomerDocumentsSchema.safeParse(body);
-        if (!parsed.success || parsed.data.workflowId !== query.workflowId || parsed.data.items.length > query.perPage)
-            throw invalid();
-    }
-}
+exports.validateAbrigoReviewResponse = void 0;
+var adapters_1 = require("@sequenceholdings/platform/adapters");
+Object.defineProperty(exports, "validateAbrigoReviewResponse", { enumerable: true, get: function () { return adapters_1.validateAbrigoReviewResponse; } });

package/dist/abrigo.d.ts

@@ -1,9 +1,9 @@
-import type { JsonValue } from './cache';
-import { type FunctionAbrigoReadRequest } from './abrigo-contract';
-export * from './abrigo-contract';
+import type { JsonValue } from "./cache";
+import { type FunctionAbrigoReadRequest } from "./abrigo-contract";
+export * from "./abrigo-contract";
 export interface FunctionCallerAbrigoOptions {
     request: {
-        headers: Pick<Headers, 'get'> | Readonly<Record<string, string | readonly string[] | undefined>>;
+        headers: Pick<Headers, "get"> | Readonly<Record<string, string | readonly string[] | undefined>>;
     };
     baseUrl: string;
     fetchImpl?: typeof globalThis.fetch;
@@ -11,4 +11,4 @@ export interface FunctionCallerAbrigoOptions {
 export interface FunctionCallerAbrigoClient {
     read(query: FunctionAbrigoReadRequest): Promise<JsonValue>;
 }
-export declare function createFunctionCallerAbrigoClient({ request, baseUrl, fetchImpl }: FunctionCallerAbrigoOptions): FunctionCallerAbrigoClient;
+export declare function createFunctionCallerAbrigoClient({ request, baseUrl, fetchImpl, }: FunctionCallerAbrigoOptions): FunctionCallerAbrigoClient;