@prestack/thread 0.0.1 → 0.0.2

package/dist/operations/errors/errors.ts

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

package/dist/operations/generators/capability.js

@@ -17,7 +17,7 @@ import { named as packageOf } from "../../core/scope.js";
 import { PREFIXES } from "../../core/thread.js";
 import { servesBrowser } from "../../integrations/target.js";
 import { CAPABILITIES_AT, CLIENT_AT, DECLARED_SEAMS_AT, MCP_AT, OPENAPI_AT, DISPATCHING_AT, SEAMS_AT, routeAt, SURFACES, switched, } from "../capabilities.js";
-import { ENVIRONMENT } from "../../core/actor.js";
+import { ANONYMOUS, ENVIRONMENT } from "../../core/actor.js";
 import { PERMITS_AT } from "../access.js";
 import { SAID as HANDED, supplies } from "../seams.js";
 import { beside, operations, quoted, runtime, types } from "./seed.js";
@@ -314,9 +314,7 @@ function settled(keeping, stores, ruled, vaulted) {
     const named = stores.map((one, at) => ({ from: beside(DECLARED_SEAMS_AT, one), as: `s${String(at)}` }));
     const only = named[0];
     return [
-        `import { ANONYMOUS, type Actor, type Environment } from '${runtime(DECLARED_SEAMS_AT, '../../core/actor.ts')}'`,
-        `import { httpSeam } from '${runtime(DECLARED_SEAMS_AT, '../http.ts')}'`,
-        `import { arrived, fresh, inMemorySeams } from '${runtime(DECLARED_SEAMS_AT, '../memory.ts')}'`,
+        `import type { Actor, Environment } from '${runtime(DECLARED_SEAMS_AT, '../../core/actor.ts')}'`,
         `import type { Seams } from '${runtime(DECLARED_SEAMS_AT, '../seams.ts')}'`,
         ...(keeping ? [`import { ENTITIES } from '${beside(DECLARED_SEAMS_AT, ENTITIES_AT)}'`] : []),
         ...(ruled ? [`import { permits } from '${beside(DECLARED_SEAMS_AT, PERMITS_AT)}'`] : []),
@@ -326,18 +324,9 @@ function settled(keeping, stores, ruled, vaulted) {
         '',
         ...(keeping
             ? [
-                'const KEPT = new Map(ENTITIES.map((one) => [one.id, new Set(one.holds.map((each) => each.id))]))',
-                '',
-                'const ADDRESSED = new Map(',
-                '  ENTITIES.flatMap((one) => {',
-                "    const held = (one.must ?? []).flatMap((each) => ('unique' in each ? each.unique : []))[0]",
-                '    return held === undefined ? [] : [[one.id, held] as const]',
-                '  }),',
-                ')',
-                '',
-                'const made = inMemorySeams({ entities: KEPT, keys: ADDRESSED }).seams',
+                'const made = {', "  log: { write(level: string, action: string, who: Actor, data: Record<string, unknown>) { console.log(JSON.stringify({ level, action, who, data })) } },", "  audit: { async append(who: Actor, record: unknown) { console.log(JSON.stringify({ audit: record, who })) } },", "  errors: { async record(who: Actor, failure: unknown) { console.error(JSON.stringify({ failure, who })) } },", '}',
             ]
-            : ['const made = inMemorySeams().seams']),
+            : ['const made = {', "  log: { write(level: string, action: string, who: Actor, data: Record<string, unknown>) { console.log(JSON.stringify({ level, action, who, data })) } },", "  audit: { async append(who: Actor, record: unknown) { console.log(JSON.stringify({ audit: record, who })) } },", "  errors: { async record(who: Actor, failure: unknown) { console.error(JSON.stringify({ failure, who })) } },", '}']),
         '',
         ...(stores.length > 1
             ? [
@@ -361,15 +350,36 @@ function settled(keeping, stores, ruled, vaulted) {
                 '',
             ]
             : []),
+        `const ANONYMOUS: Actor = ${JSON.stringify(ANONYMOUS)}`,
+        '',
+        "const http: NonNullable<Seams['http']> = {",
+        '  async call(request) {',
+        '    const base = new URL(request.address)',
+        "    if (base.protocol !== 'https:') throw new Error(request.target + ' is reached over ' + base.protocol + ' and an outward call goes over https only')",
+        '    const stem = base.pathname.length === 1 ? String() : base.pathname',
+        '    const url = new URL(base.origin + stem + request.path)',
+        "    if (url.origin !== base.origin) throw new Error(request.path + ' resolves to ' + url.origin + ', which is not where ' + request.target + ' is')",
+        '    const headers: Record<string, string> = { ...request.headers }',
+        "    if (request.contentType !== undefined) headers['content-type'] = request.contentType",
+        '    const carried = new Uint8Array(request.body === undefined ? 0 : request.body.byteLength)',
+        '    if (request.body !== undefined) carried.set(request.body)',
+        '    const began = Date.now()',
+        '    const sent = JSON.stringify(headers).length + (request.body === undefined ? 0 : request.body.byteLength)',
+        '    const answered = await fetch(url.toString(), { method: request.method, headers, ...(request.body === undefined ? {} : { body: carried }), signal: AbortSignal.timeout(10000) })',
+        '    const body = new Uint8Array(await answered.arrayBuffer())',
+        '    return { status: answered.status, headers: Object.fromEntries(answered.headers.entries()), body, bytesSent: sent, bytesReceived: body.byteLength, durationMs: Date.now() - began }',
+        '  },',
+        '}',
+        '',
         'const shared = globalThis as { __threadSeams?: Seams }',
         '',
         'export const DECLARED: Seams = (shared.__threadSeams ??= {',
         '  ...made,',
         ...(stores.length === 1 ? ['  store: kept,'] : []),
         ...(stores.length > 1 ? ['  store,'] : []),
-        '  clock: { now: arrived },',
-        '  random: { next: Math.random, uuid: fresh },',
-        '  http: httpSeam(),',
+        '  clock: { now: () => Date.now() },',
+        '  random: { next: Math.random, uuid: () => crypto.randomUUID() },',
+        '  http,',
         ...(ruled ? ['  permits: { check: (actor, action, resource) => Promise.resolve(permits(actor, action, resource)) },'] : []),
         ...(vaulted ? ['  vault: { resolve: opening },'] : []),
         '})',
@@ -464,7 +474,7 @@ function dispatching(found) {
     return [
         '/* GENERATED by thread — do not edit. It is derived from what this app declares. */',
         '',
-        `declare module '${packageOf('ui')}/checked' {`,
+        `declare module '${packageOf('ui')}/ui/checked' {`,
         ...(reachable.length === 0
             ? ['  interface Dispatching {}']
             : ['  interface Dispatching {', ...reachable.map((one) => `    readonly ${one.operation}: true`), '  }']),