@prestack/thread 0.1.21 → 0.1.23

package/dist/operations/nodes.ts

@@ -1,53 +0,0 @@
-import type { Threaded } from '../core/thread.ts'
-
-import type { Opened, Operation, Reads } from './operations.ts'
-
-export interface Node extends Threaded {
-  readonly version: number
-}
-
-export type Held<I = unknown> = Parameters<Operation<I>['run']>[1]
-
-export const STOPPED = Symbol.for('thread.operation.stopped')
-
-export function stopped(thrown: unknown): { readonly value: unknown } | undefined {
-  if (typeof thrown !== 'object' || thrown === null) return undefined
-  if ((thrown as Record<symbol, unknown>)[STOPPED] !== true) return undefined
-  return { value: (thrown as { readonly value?: unknown }).value }
-}
-
-export const nd_read = <I, R extends string = never>(
-  block: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<unknown>,
-) => ({ type: 'nd_read' as const })
-
-export const nd_action = <I, R extends string = never>(
-  block: (opened: Opened<R>, held: Held<I>) => Promise<unknown>,
-) => ({ type: 'nd_action' as const })
-
-export const nd_branch = <I, R extends string = never>(
-  choose: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<string>,
-  ways: Readonly<Record<string, (opened: Opened<R>, held: Held<I>) => Promise<unknown>>>,
-) => ({ type: 'nd_branch' as const })
-
-export const nd_each = <I, R extends string = never>(
-  over: (held: Held<I>) => readonly unknown[],
-  block: (item: unknown, opened: Opened<R>, held: Held<I>) => Promise<unknown>,
-) => ({ type: 'nd_each' as const })
-
-export const nd_parallel = <I, R extends string = never>(
-  blocks: readonly ((opened: Opened<R>, held: Held<I>) => Promise<unknown>)[],
-) => ({ type: 'nd_parallel' as const })
-
-export const nd_repeat = <I, R extends string = never>(
-  ceiling: number,
-  block: (
-    pass: number,
-    carried: unknown,
-    opened: Opened<R>,
-    held: Held<I>,
-  ) => Promise<{ readonly done: boolean; readonly value: unknown }>,
-) => ({ type: 'nd_repeat' as const })
-
-export const nd_stop = <I, R extends string = never>(
-  block: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<unknown>,
-) => ({ type: 'nd_stop' as const })

package/dist/operations/operations.ts

@@ -1,91 +0,0 @@
-import type { z } from 'zod'
-
-import type { Actor } from '../core/actor.ts'
-import type { Member } from '../core/thread.ts'
-import { REACH, type Answering, type Calling, type HttpResponse, type Row, type Running, type Store } from '../integrations/target.ts'
-
-import type { Surface } from './capabilities.ts'
-
-export const OPERATIONS_FILE = 'operations.ts'
-
-export const TRIALS_AT = 'operations/_trials.json'
-
-export const NODES_FILE = 'nodes.ts'
-
-export const MEMBERS_LIST = 'MEMBERS'
-
-export interface Reaching {}
-
-type CallsOf<K extends string> = K extends keyof Reaching ? (Reaching[K] extends string ? Reaching[K] : string) : string
-
-export type Opened<R extends string = never> = { readonly actor: Actor; readonly tell: (said: unknown) => void } & {
-  readonly [K in R]: K extends `${typeof REACH.disk}${string}`
-    ? Answering
-    : K extends `${typeof REACH.cli}${string}`
-      ? Running<CallsOf<K>>
-      : K extends `${typeof REACH.postgres}${string}` | `${typeof REACH.pglite}${string}` | `${typeof REACH.browser}${string}`
-        ? Store
-      : K extends `${typeof REACH.sdk}${string}`
-        ? Calling<CallsOf<K>>
-      : Readonly<
-          Record<
-            CallsOf<K>,
-            (given?: {
-              readonly fills?: Readonly<Record<string, string | number>>
-              readonly json?: unknown
-              readonly body?: Uint8Array
-              readonly contentType?: string
-              readonly told?: (said: unknown) => void
-            }) => Promise<HttpResponse>
-          >
-        >
-}
-
-export type Reads<H> = { readonly [K in keyof H]: H[K] extends Store ? Pick<Store, 'get' | 'list'> : H[K] }
-
-export const WINDOWS = ['second', 'minute', 'hour', 'day', 'week', 'month'] as const
-
-export type Window = (typeof WINDOWS)[number]
-
-export interface Allowance {
-  readonly runs: number
-
-  readonly per: Window
-}
-
-export interface Counting {
-  readonly seen: (key: string, per: Window) => Promise<number>
-}
-
-export interface Operation<I = unknown, R extends string = never> {
-  readonly id: string
-
-  readonly input: z.ZodType<I>
-
-  readonly requires: readonly string[]
-
-  readonly webhooks?: readonly string[]
-
-  readonly off?: readonly Surface[]
-
-  readonly signed?: boolean
-
-  readonly entitled?: string
-
-  readonly rate?: Allowance
-
-  readonly quota?: Allowance
-
-  readonly run: (
-    opened: Opened<R>,
-    held: { readonly input: I } & Readonly<Record<string, unknown>>,
-  ) => Promise<unknown>
-
-  readonly timeout: number
-
-  readonly resource: (input: I) => Row | null
-}
-
-export type OperationMember = Member & Pick<Operation, 'timeout' | 'webhooks' | 'off' | 'signed' | 'entitled' | 'rate' | 'quota'>
-
-export const OPERATIONS: readonly Member[] = []

package/dist/operations/result.ts

@@ -1,28 +0,0 @@
-import type { ErrorCode, ErrorDef } from '../core/errors/error.ts'
-import type { ErrorClass } from '../core/errors/classes.ts'
-
-export type ResultCode = 'denied' | 'invalid' | 'rate_limited' | 'feature_denied' | 'quota_exceeded' | 'error'
-
-export type FailureIdentity = Pick<ErrorDef, 'code' | 'class'>
-
-export type Result<O> =
-  | { ok: true; value: O }
-  | {
-      ok: false
-      code: ResultCode
-      error: string
-      because?: string
-      errorCode?: ErrorCode
-      errorClass?: ErrorClass
-    }
-
-export const ok = <O>(value: O): Result<O> => ({ ok: true, value })
-export const fail = <O>(code: ResultCode, error: string, because?: string, identity?: FailureIdentity): Result<O> => ({
-  ok: false,
-  code,
-  error,
-  because,
-  ...(identity === undefined ? {} : { errorCode: identity.code, errorClass: identity.class }),
-})
-
-export class ValidationError extends Error {}