@prestack/thread 0.1.3 → 0.1.4

package/dist/operations/errors/errors.d.ts

@@ -1,52 +0,0 @@
-export declare const AuthUnauthenticated: import("./catalog.ts").ErrorFactory<"auth.unauthenticated">;
-export declare const AuthInvalidCredentials: import("./catalog.ts").ErrorFactory<"auth.invalid_credentials">;
-export declare const AuthTokenExpired: import("./catalog.ts").ErrorFactory<"auth.token_expired">;
-export declare const AuthTokenReused: import("./catalog.ts").ErrorFactory<"auth.token_reused">;
-export declare const AuthSessionRevoked: import("./catalog.ts").ErrorFactory<"auth.session_revoked">;
-export declare const AuthDenied: import("./catalog.ts").ErrorFactory<"auth.denied">;
-export declare const QuotaExceeded: import("./catalog.ts").ErrorFactory<"quota.exceeded">;
-export declare const QuotaReservationExpired: import("./catalog.ts").ErrorFactory<"quota.reservation_expired">;
-export declare const RateLimitExceeded: import("./catalog.ts").ErrorFactory<"rate_limit.exceeded">;
-export declare const FeatureNotInPlan: import("./catalog.ts").ErrorFactory<"feature.not_in_plan">;
-export declare const DbNotFound: import("./catalog.ts").ErrorFactory<"db.not_found">;
-export declare const DbConstraintViolation: import("./catalog.ts").ErrorFactory<"db.constraint_violation">;
-export declare const DbAlreadyExists: import("./catalog.ts").ErrorFactory<"db.already_exists">;
-export declare const DbConflict: import("./catalog.ts").ErrorFactory<"db.conflict">;
-export declare const DbMigrationChecksumMismatch: import("./catalog.ts").ErrorFactory<"db.migration_checksum_mismatch">;
-export declare const DbDestructiveWithoutDryRun: import("./catalog.ts").ErrorFactory<"db.destructive_without_dry_run">;
-export declare const DbRoundTripBudgetExceeded: import("./catalog.ts").ErrorFactory<"db.round_trip_budget_exceeded">;
-export declare const DbCursorInvalid: import("./catalog.ts").ErrorFactory<"db.cursor_invalid">;
-export declare const DbCursorExpired: import("./catalog.ts").ErrorFactory<"db.cursor_expired">;
-export declare const WorkflowNodeFailed: import("./catalog.ts").ErrorFactory<"workflow.node_failed">;
-export declare const WorkflowInvalidTransition: import("./catalog.ts").ErrorFactory<"workflow.invalid_transition">;
-export declare const WorkflowCompensationFailed: import("./catalog.ts").ErrorFactory<"workflow.compensation_failed">;
-export declare const WorkflowAlreadyRunning: import("./catalog.ts").ErrorFactory<"workflow.already_running">;
-export declare const QueueJobFailed: import("./catalog.ts").ErrorFactory<"queue.job_failed">;
-export declare const QueueDlqExhausted: import("./catalog.ts").ErrorFactory<"queue.dlq_exhausted">;
-export declare const AiProviderUnavailable: import("./catalog.ts").ErrorFactory<"ai.provider_unavailable">;
-export declare const AiSchemaValidationFailed: import("./catalog.ts").ErrorFactory<"ai.schema_validation_failed">;
-export declare const AiToolNotInMask: import("./catalog.ts").ErrorFactory<"ai.tool_not_in_mask">;
-export declare const AiNodeCapExceeded: import("./catalog.ts").ErrorFactory<"ai.node_cap_exceeded">;
-export declare const SearchIndexFailed: import("./catalog.ts").ErrorFactory<"search.index_failed">;
-export declare const SearchQueryInvalid: import("./catalog.ts").ErrorFactory<"search.query_invalid">;
-export declare const CommsChannelKindUndeclared: import("./catalog.ts").ErrorFactory<"comms.channel_kind_undeclared">;
-export declare const CommsChannelKindUndescribed: import("./catalog.ts").ErrorFactory<"comms.channel_kind_undescribed">;
-export declare const CommsChannelKindUnlabelled: import("./catalog.ts").ErrorFactory<"comms.channel_kind_unlabelled">;
-export declare const CommsChannelKindUndocumented: import("./catalog.ts").ErrorFactory<"comms.channel_kind_undocumented">;
-export declare const CommsChannelKindDuplicate: import("./catalog.ts").ErrorFactory<"comms.channel_kind_duplicate">;
-export declare const ConfigInvalid: import("./catalog.ts").ErrorFactory<"config.invalid">;
-export declare const ConfigMissingEnv: import("./catalog.ts").ErrorFactory<"config.missing_env">;
-export declare const ConfigSecretInPublicVar: import("./catalog.ts").ErrorFactory<"config.secret_in_public_var">;
-export declare const ConfigCredentialInvalid: import("./catalog.ts").ErrorFactory<"config.credential_invalid">;
-export declare const ConfigScopeMissing: import("./catalog.ts").ErrorFactory<"config.scope_missing">;
-export declare const ConfigResourceNotFound: import("./catalog.ts").ErrorFactory<"config.resource_not_found">;
-export declare const ConfigDestinationIncompatible: import("./catalog.ts").ErrorFactory<"config.destination_incompatible">;
-export declare const ConfigBlocksExit: import("./catalog.ts").ErrorFactory<"config.blocks_exit">;
-export declare const NetTimeout: import("./catalog.ts").ErrorFactory<"net.timeout">;
-export declare const NetUpstreamUnavailable: import("./catalog.ts").ErrorFactory<"net.upstream_unavailable">;
-export declare const NetDestinationRefused: import("./catalog.ts").ErrorFactory<"net.destination_refused">;
-export declare const InternalUnexpected: import("./catalog.ts").ErrorFactory<"internal.unexpected">;
-export declare const InternalNotImplemented: import("./catalog.ts").ErrorFactory<"internal.not_implemented">;
-export declare const InternalInvalidArgument: import("./catalog.ts").ErrorFactory<"internal.invalid_argument">;
-export declare const PLATFORM_ERRORS: readonly [import("./catalog.ts").ErrorFactory<"auth.unauthenticated">, import("./catalog.ts").ErrorFactory<"auth.invalid_credentials">, import("./catalog.ts").ErrorFactory<"auth.token_expired">, import("./catalog.ts").ErrorFactory<"auth.token_reused">, import("./catalog.ts").ErrorFactory<"auth.session_revoked">, import("./catalog.ts").ErrorFactory<"auth.denied">, import("./catalog.ts").ErrorFactory<"quota.exceeded">, import("./catalog.ts").ErrorFactory<"quota.reservation_expired">, import("./catalog.ts").ErrorFactory<"rate_limit.exceeded">, import("./catalog.ts").ErrorFactory<"feature.not_in_plan">, import("./catalog.ts").ErrorFactory<"db.not_found">, import("./catalog.ts").ErrorFactory<"db.constraint_violation">, import("./catalog.ts").ErrorFactory<"db.already_exists">, import("./catalog.ts").ErrorFactory<"db.conflict">, import("./catalog.ts").ErrorFactory<"db.migration_checksum_mismatch">, import("./catalog.ts").ErrorFactory<"db.destructive_without_dry_run">, import("./catalog.ts").ErrorFactory<"db.round_trip_budget_exceeded">, import("./catalog.ts").ErrorFactory<"db.cursor_invalid">, import("./catalog.ts").ErrorFactory<"db.cursor_expired">, import("./catalog.ts").ErrorFactory<"workflow.node_failed">, import("./catalog.ts").ErrorFactory<"workflow.invalid_transition">, import("./catalog.ts").ErrorFactory<"workflow.compensation_failed">, import("./catalog.ts").ErrorFactory<"workflow.already_running">, import("./catalog.ts").ErrorFactory<"queue.job_failed">, import("./catalog.ts").ErrorFactory<"queue.dlq_exhausted">, import("./catalog.ts").ErrorFactory<"ai.provider_unavailable">, import("./catalog.ts").ErrorFactory<"ai.schema_validation_failed">, import("./catalog.ts").ErrorFactory<"ai.tool_not_in_mask">, import("./catalog.ts").ErrorFactory<"ai.node_cap_exceeded">, import("./catalog.ts").ErrorFactory<"search.index_failed">, import("./catalog.ts").ErrorFactory<"search.query_invalid">, import("./catalog.ts").ErrorFactory<"comms.channel_kind_undeclared">, import("./catalog.ts").ErrorFactory<"comms.channel_kind_undescribed">, import("./catalog.ts").ErrorFactory<"comms.channel_kind_unlabelled">, import("./catalog.ts").ErrorFactory<"comms.channel_kind_undocumented">, import("./catalog.ts").ErrorFactory<"comms.channel_kind_duplicate">, import("./catalog.ts").ErrorFactory<"config.invalid">, import("./catalog.ts").ErrorFactory<"config.missing_env">, import("./catalog.ts").ErrorFactory<"config.secret_in_public_var">, import("./catalog.ts").ErrorFactory<"config.credential_invalid">, import("./catalog.ts").ErrorFactory<"config.scope_missing">, import("./catalog.ts").ErrorFactory<"config.resource_not_found">, import("./catalog.ts").ErrorFactory<"config.destination_incompatible">, import("./catalog.ts").ErrorFactory<"config.blocks_exit">, import("./catalog.ts").ErrorFactory<"net.timeout">, import("./catalog.ts").ErrorFactory<"net.upstream_unavailable">, import("./catalog.ts").ErrorFactory<"net.destination_refused">, import("./catalog.ts").ErrorFactory<"internal.unexpected">, import("./catalog.ts").ErrorFactory<"internal.not_implemented">, import("./catalog.ts").ErrorFactory<"internal.invalid_argument">];
-export type PlatformErrorCode = (typeof PLATFORM_ERRORS)[number]['def']['code'];

package/dist/operations/http.js

@@ -1,124 +0,0 @@
-import { payloadBytes } from "./metering.js";
-import { ValidationError } from "./result.js";
-export const HTTP_CALL_ACTION = 'http.call';
-export class HttpNotConfiguredError extends Error {
-    constructor() {
-        super('no outward seam is configured. `http.call` needs `seams.http`, which is the transport an app ' +
-            'wires — which hosts it may reach is declared in its tree and is not this seam\'s business.');
-        this.name = 'HttpNotConfiguredError';
-    }
-}
-export class OutwardTransportError extends Error {
-    target;
-    constructor(target, cause) {
-        super(`outward call to "${target}" never reached it: ${cause instanceof Error ? cause.message : String(cause)}`);
-        this.target = target;
-        this.name = 'OutwardTransportError';
-    }
-}
-export function outwardUrl(target, address, path) {
-    let base;
-    try {
-        base = new URL(address);
-    }
-    catch {
-        throw new ValidationError(`the address resolved for "${target}" is not an absolute URL: ${JSON.stringify(address)}`);
-    }
-    if (base.protocol !== 'https:') {
-        throw new ValidationError(`outward calls go over https only, and "${target}" resolved to ${base.protocol.replace(':', '')}`);
-    }
-    if (base.search !== '' || base.hash !== '') {
-        throw new ValidationError(`the address for "${target}" carries a query or a fragment — those belong to the call`);
-    }
-    if (!path.startsWith('/')) {
-        throw new ValidationError(`an outward path starts with "/", and "${path}" does not`);
-    }
-    if (path.startsWith('//')) {
-        throw new ValidationError(`the path "${path}" is protocol-relative, which points at another host`);
-    }
-    const url = new URL(`${base.origin}${base.pathname.replace(/\/$/, '')}${path}`);
-    if (url.origin !== base.origin) {
-        throw new ValidationError(`the path "${path}" resolves to ${url.origin}, which is not where "${target}" is`);
-    }
-    return url;
-}
-function requestBytes(headers, body) {
-    return payloadBytes(headers) + (body === undefined ? 0 : body.byteLength);
-}
-function wireBody(body) {
-    const copy = new ArrayBuffer(body.byteLength);
-    new Uint8Array(copy).set(body);
-    return copy;
-}
-const DEFAULT_TIMEOUT_MS = 10_000;
-export function httpSeam(options = {}) {
-    const send = options.transport ?? fetch;
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    return {
-        async call(request) {
-            const url = outwardUrl(request.target, request.address, request.path);
-            const headers = { ...request.headers };
-            if (request.contentType !== undefined)
-                headers['content-type'] = request.contentType;
-            if (request.idempotencyKey !== undefined)
-                headers['idempotency-key'] = request.idempotencyKey;
-            const bytesSent = requestBytes(headers, request.body);
-            const startedAt = Date.now();
-            let response;
-            try {
-                response = await send(url.toString(), {
-                    method: request.method,
-                    headers,
-                    ...(request.body === undefined ? {} : { body: wireBody(request.body) }),
-                    signal: AbortSignal.timeout(timeoutMs),
-                });
-            }
-            catch (error) {
-                throw new OutwardTransportError(request.target, error);
-            }
-            const body = new Uint8Array(await response.arrayBuffer());
-            const responseHeaders = Object.fromEntries(response.headers.entries());
-            return {
-                status: response.status,
-                headers: responseHeaders,
-                body,
-                bytesSent,
-                bytesReceived: payloadBytes(responseHeaders) + body.byteLength,
-                durationMs: Date.now() - startedAt,
-            };
-        },
-    };
-}
-const REDACTED = '(sent)';
-export function recordingHttp(script = {}) {
-    const calls = [];
-    const decoder = new TextDecoder();
-    return {
-        calls,
-        async call(request) {
-            outwardUrl(request.target, request.address, request.path);
-            const body = request.body === undefined ? '' : decoder.decode(request.body);
-            calls.push({
-                target: request.target,
-                method: request.method,
-                path: request.path,
-                headers: Object.fromEntries(Object.keys(request.headers ?? {}).map((one) => [one, REDACTED])),
-                body,
-            });
-            const answer = script[`${request.method} ${request.path}`];
-            if (answer === undefined) {
-                throw new Error(`this scenario scripts no answer for "${request.method} ${request.path}", so nothing here knows what ${request.target} would say. Add that key to the scenario's answers — a call answered by something nobody scripted proves it was made and nothing about what came back.`);
-            }
-            const answered = new TextEncoder().encode(answer.body ?? '');
-            const headers = answer.headers ?? {};
-            return {
-                status: answer.status,
-                headers,
-                body: answered,
-                bytesSent: requestBytes({ ...request.headers }, request.body),
-                bytesReceived: payloadBytes(headers) + answered.byteLength,
-                durationMs: 0,
-            };
-        },
-    };
-}

package/dist/operations/http.ts

@@ -1,169 +0,0 @@
-import { payloadBytes } from './metering.ts'
-import { ValidationError } from './result.ts'
-import type { Http, HttpRequest, HttpResponse } from './seams.ts'
-
-export const HTTP_CALL_ACTION = 'http.call'
-
-export class HttpNotConfiguredError extends Error {
-  constructor() {
-    super(
-      'no outward seam is configured. `http.call` needs `seams.http`, which is the transport an app ' +
-        'wires — which hosts it may reach is declared in its tree and is not this seam\'s business.',
-    )
-    this.name = 'HttpNotConfiguredError'
-  }
-}
-
-export class OutwardTransportError extends Error {
-  constructor(
-    readonly target: string,
-    cause: unknown,
-  ) {
-    super(`outward call to "${target}" never reached it: ${cause instanceof Error ? cause.message : String(cause)}`)
-    this.name = 'OutwardTransportError'
-  }
-}
-
-export function outwardUrl(target: string, address: string, path: string): URL {
-  let base: URL
-  try {
-    base = new URL(address)
-  } catch {
-    throw new ValidationError(`the address resolved for "${target}" is not an absolute URL: ${JSON.stringify(address)}`)
-  }
-  if (base.protocol !== 'https:') {
-    throw new ValidationError(`outward calls go over https only, and "${target}" resolved to ${base.protocol.replace(':', '')}`)
-  }
-  if (base.search !== '' || base.hash !== '') {
-    throw new ValidationError(`the address for "${target}" carries a query or a fragment — those belong to the call`)
-  }
-  if (!path.startsWith('/')) {
-    throw new ValidationError(`an outward path starts with "/", and "${path}" does not`)
-  }
-  if (path.startsWith('//')) {
-    throw new ValidationError(`the path "${path}" is protocol-relative, which points at another host`)
-  }
-  const url = new URL(`${base.origin}${base.pathname.replace(/\/$/, '')}${path}`)
-  if (url.origin !== base.origin) {
-    throw new ValidationError(`the path "${path}" resolves to ${url.origin}, which is not where "${target}" is`)
-  }
-  return url
-}
-
-function requestBytes(headers: Readonly<Record<string, string>>, body: Uint8Array | undefined): number {
-  return payloadBytes(headers) + (body === undefined ? 0 : body.byteLength)
-}
-
-function wireBody(body: Uint8Array): ArrayBuffer {
-  const copy = new ArrayBuffer(body.byteLength)
-  new Uint8Array(copy).set(body)
-  return copy
-}
-
-export interface HttpSeamOptions {
-  readonly transport?: typeof fetch
-
-  readonly timeoutMs?: number
-}
-
-const DEFAULT_TIMEOUT_MS = 10_000
-
-export function httpSeam(options: HttpSeamOptions = {}): Http {
-  const send = options.transport ?? fetch
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS
-
-  return {
-    async call(request: HttpRequest): Promise<HttpResponse> {
-      const url = outwardUrl(request.target, request.address, request.path)
-
-      const headers: Record<string, string> = { ...request.headers }
-      if (request.contentType !== undefined) headers['content-type'] = request.contentType
-      if (request.idempotencyKey !== undefined) headers['idempotency-key'] = request.idempotencyKey
-
-      const bytesSent = requestBytes(headers, request.body)
-      const startedAt = Date.now()
-
-      let response: Response
-      try {
-        response = await send(url.toString(), {
-          method: request.method,
-          headers,
-          ...(request.body === undefined ? {} : { body: wireBody(request.body) }),
-          signal: AbortSignal.timeout(timeoutMs),
-        })
-      } catch (error) {
-
-        throw new OutwardTransportError(request.target, error)
-      }
-
-      const body = new Uint8Array(await response.arrayBuffer())
-      const responseHeaders = Object.fromEntries(response.headers.entries())
-
-      return {
-        status: response.status,
-        headers: responseHeaders,
-        body,
-        bytesSent,
-        bytesReceived: payloadBytes(responseHeaders) + body.byteLength,
-        durationMs: Date.now() - startedAt,
-      }
-    },
-  }
-}
-
-export interface RecordedCall {
-  readonly target: string
-  readonly method: string
-  readonly path: string
-  readonly headers: Readonly<Record<string, string>>
-  readonly body: string
-}
-
-export interface ScriptedAnswer {
-  readonly status: number
-  readonly headers?: Readonly<Record<string, string>>
-  readonly body?: string
-}
-
-const REDACTED = '(sent)'
-
-export function recordingHttp(
-  script: Readonly<Record<string, ScriptedAnswer>> = {},
-): Http & { readonly calls: readonly RecordedCall[] } {
-  const calls: RecordedCall[] = []
-  const decoder = new TextDecoder()
-
-  return {
-    calls,
-    async call(request) {
-      outwardUrl(request.target, request.address, request.path)
-
-      const body = request.body === undefined ? '' : decoder.decode(request.body)
-      calls.push({
-        target: request.target,
-        method: request.method,
-        path: request.path,
-        headers: Object.fromEntries(Object.keys(request.headers ?? {}).map((one) => [one, REDACTED])),
-        body,
-      })
-
-      const answer = script[`${request.method} ${request.path}`]
-      if (answer === undefined) {
-        throw new Error(
-          `this scenario scripts no answer for "${request.method} ${request.path}", so nothing here knows what ${request.target} would say. Add that key to the scenario's answers — a call answered by something nobody scripted proves it was made and nothing about what came back.`,
-        )
-      }
-      const answered = new TextEncoder().encode(answer.body ?? '')
-      const headers = answer.headers ?? {}
-      return {
-        status: answer.status,
-        headers,
-        body: answered,
-        bytesSent: requestBytes({ ...request.headers }, request.body),
-        bytesReceived: payloadBytes(headers) + answered.byteLength,
-
-        durationMs: 0,
-      }
-    },
-  }
-}

package/dist/operations/memory.d.ts

@@ -1,104 +0,0 @@
-import type { Actor } from '../core/actor.ts';
-import type { Store, Row, Seams, Idempotency, PlatformEvent, LogLevel, Queue, Job, EnqueueOpts, Transactional, AuditRecord, ErrorRecord, Vault, FieldList } from './seams.ts';
-export declare class UnknownColumnError extends Error {
-    constructor(entity: string, key: string);
-}
-export declare class VersionConflictError extends Error {
-    constructor(entity: string, id: string, expectedVersion: number);
-}
-export declare class MemoryStore implements Store, Transactional {
-    private data;
-    private readonly declared;
-    private readonly keys;
-    constructor(declared?: ReadonlyMap<string, ReadonlySet<string>>, keys?: ReadonlyMap<string, string>);
-    private keyOf;
-    private static readonly SYSTEM;
-    private assertDeclared;
-    private depth;
-    transaction<T>(_actor: Actor, fn: () => Promise<T>): Promise<T>;
-    insert(_actor: Actor, entity: string, row: Row): Promise<Row>;
-    get(_actor: Actor, entity: string, key: string | number, fields: FieldList): Promise<Row | null>;
-    list(_actor: Actor, entity: string, opts?: {
-        limit?: number;
-        where?: Readonly<Record<string, string | number | boolean | null>>;
-    }): Promise<Row[]>;
-    update(_actor: Actor, entity: string, key: string | number, patch: Record<string, unknown>, expectedVersion?: number): Promise<Row>;
-    remove(_actor: Actor, entity: string, key: string | number): Promise<void>;
-}
-export declare class MemoryQueue implements Queue {
-    private jobs;
-    private dead;
-    private seq;
-    enqueue<T>(actor: Actor, kind: string, payload: T, opts?: EnqueueOpts): Promise<string>;
-    poll(kinds: string[], limit: number, now: number): Promise<Job[]>;
-    ack(id: string): Promise<void>;
-    fail(id: string, error: string, now: number): Promise<void>;
-    deadLetter(id: string, error: string): Promise<void>;
-    deadLetters(): Promise<Job[]>;
-}
-export interface Sink {
-    logs: {
-        level: LogLevel;
-        action: string;
-        data: Record<string, unknown>;
-    }[];
-    events: PlatformEvent[];
-    audits: AuditRecord[];
-    errors: ErrorRecord[];
-    costs: string[];
-    indexed: {
-        entity: string;
-        row: Row;
-    }[];
-    spans: {
-        action: string;
-        status: 'ok' | 'error';
-    }[];
-    outbox: PlatformEvent[];
-    gateOrder: string[];
-    quota: {
-        reserved: number[];
-        committed: number[];
-        released: number;
-    };
-    files: {
-        action: 'put' | 'get' | 'signed' | 'remove';
-        key: string;
-        bytes: number | null;
-    }[];
-    queries: {
-        sql: string;
-        params: readonly unknown[];
-        rows: number;
-    }[];
-}
-export declare class MemoryIdempotency implements Idempotency {
-    private readonly records;
-    private readonly onCheck?;
-    constructor(opts: {
-        readonly onCheck?: () => void;
-        readonly records?: Map<string, unknown>;
-    });
-    private keyFor;
-    check(key: string | undefined, action: string): Promise<unknown | null>;
-    store(key: string | undefined, action: string, output: unknown): Promise<void>;
-}
-export interface MemorySeamOptions {
-    readonly allowRate?: boolean;
-    readonly features?: readonly string[];
-    readonly quota?: Readonly<Record<string, number>>;
-    readonly onExceed?: string;
-    readonly entities?: ReadonlyMap<string, ReadonlySet<string>>;
-    readonly keys?: ReadonlyMap<string, string>;
-    readonly secrets?: Readonly<Record<string, string>>;
-    readonly views?: Readonly<Record<string, readonly unknown[]>>;
-}
-export declare function memoryVault(seed?: Readonly<Record<string, string>>): Vault;
-export declare const arrived: () => number;
-export declare const fresh: () => string;
-export declare function inMemorySeams(opts?: MemorySeamOptions): {
-    seams: Seams;
-    sink: Sink;
-    store: MemoryStore;
-    queue: MemoryQueue;
-};