@pikku/core 0.11.2 → 0.12.1

package/dist/wirings/workflow/workflow.types.d.ts

@@ -1,8 +1,13 @@
-import { SerializedError, CommonWireMeta } from '../../types/core.types.js';
-import { CorePikkuFunctionConfig } from '../../function/functions.types.js';
+import type { SerializedError, CommonWireMeta } from '../../types/core.types.js';
+import type { CorePikkuFunctionConfig } from '../../function/functions.types.js';
 export type { WorkflowService } from '../../services/workflow-service.js';
-export type { WorkflowStepOptions, WorkflowWireDoRPC, WorkflowWireDoInline, WorkflowWireSleep, InputSource, OutputBinding, RpcStepMeta, SimpleCondition, Condition, BranchCase, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, SetStepMeta, SwitchCaseMeta, SwitchStepMeta, FilterStepMeta, ArrayPredicateStepMeta, WorkflowStepMeta, WorkflowStepWire, PikkuWorkflowWire, } from './dsl/workflow-dsl.types.js';
+export type { WorkflowStepOptions, WorkflowWireDoRPC, WorkflowWireDoInline, WorkflowWireSleep, WorkflowWireSuspend, InputSource, OutputBinding, RpcStepMeta, SimpleCondition, Condition, BranchCase, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, SetStepMeta, SwitchCaseMeta, SwitchStepMeta, FilterStepMeta, ArrayPredicateStepMeta, WorkflowStepMeta, WorkflowStepWire, PikkuWorkflowWire, } from './dsl/workflow-dsl.types.js';
 import type { WorkflowStepMeta } from './dsl/workflow-dsl.types.js';
+export interface WorkflowRunWire {
+    type: string;
+    id?: string;
+    parentRunId?: string;
+}
 export interface WorkflowServiceConfig {
     retries: number;
     retryDelay: number;
@@ -10,99 +15,14 @@ export interface WorkflowServiceConfig {
     stepWorkerQueueName: string;
     sleeperRPCName: string;
 }
-/**
- * HTTP wire configuration for workflows
- */
-export interface WorkflowHTTPWire {
-    route: string;
-    method: 'get' | 'post' | 'put' | 'patch' | 'delete';
-    startNode: string;
-}
-/**
- * Channel wire configuration for workflows
- */
-export interface WorkflowChannelWire {
-    name: string;
-    onConnect?: string;
-    onDisconnect?: string;
-    onMessage?: string;
-}
-/**
- * Queue wire configuration for workflows
- */
-export interface WorkflowQueueWire {
-    name: string;
-    startNode: string;
-}
-/**
- * CLI wire configuration for workflows
- */
-export interface WorkflowCliWire {
-    command: string;
-    startNode: string;
-}
-/**
- * MCP wire configurations for workflows
- */
-export interface WorkflowMcpWires {
-    tool?: Array<{
-        name: string;
-        startNode: string;
-    }>;
-    prompt?: Array<{
-        name: string;
-        startNode: string;
-    }>;
-    resource?: Array<{
-        uri: string;
-        startNode: string;
-    }>;
-}
-/**
- * Schedule wire configuration for workflows
- */
-export interface WorkflowScheduleWire {
-    cron?: string;
-    interval?: string;
-    startNode: string;
-}
-/**
- * Trigger wire configuration for workflows
- */
-export interface WorkflowTriggerWire {
-    name: string;
-    startNode: string;
-}
-/**
- * Wire configuration for workflows
- * Defines how a workflow can be triggered
- */
-export interface WorkflowWires {
-    /** API entry point - node ID for startWorkflow() calls */
-    api?: string;
-    /** HTTP triggers */
-    http?: WorkflowHTTPWire[];
-    /** Channel triggers */
-    channel?: WorkflowChannelWire[];
-    /** Queue triggers */
-    queue?: WorkflowQueueWire[];
-    /** CLI triggers */
-    cli?: WorkflowCliWire[];
-    /** MCP triggers (tool, prompt, resource) */
-    mcp?: WorkflowMcpWires;
-    /** Schedule triggers */
-    schedule?: WorkflowScheduleWire[];
-    /** Named trigger wires */
-    trigger?: WorkflowTriggerWire[];
-}
 /**
  * Workflow run status
  */
-export type WorkflowStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export type WorkflowStatus = 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled';
 /**
  * Workflow step status
  */
-export type StepStatus = 'pending' | 'running' | 'scheduled' | 'succeeded' | 'failed';
+export type StepStatus = 'pending' | 'running' | 'scheduled' | 'succeeded' | 'failed' | 'suspended';
 /**
  * Workflow run representation
  */
@@ -121,6 +41,10 @@ export interface WorkflowRun {
     error?: SerializedError;
     /** If true, workflow executes inline without queues */
     inline?: boolean;
+    /** Graph hash of the workflow definition at run creation time */
+    graphHash?: string;
+    /** Wire origin info (how this run was started) */
+    wire: WorkflowRunWire;
     /** Creation timestamp */
     createdAt: Date;
     /** Last update timestamp */
@@ -157,6 +81,29 @@ export interface StepState {
     /** Timestamp when step failed */
     failedAt?: Date;
 }
+export interface WorkflowRunService {
+    listRuns(options?: {
+        workflowName?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<WorkflowRun[]>;
+    getRun(id: string): Promise<WorkflowRun | null>;
+    getRunSteps(runId: string): Promise<Array<StepState & {
+        stepName: string;
+        rpcName?: string;
+        data?: any;
+    }>>;
+    getRunHistory(runId: string): Promise<Array<StepState & {
+        stepName: string;
+    }>>;
+    getDistinctWorkflowNames(): Promise<string[]>;
+    getWorkflowVersion(name: string, graphHash: string): Promise<{
+        graph: any;
+        source: string;
+    } | null>;
+    deleteRun(id: string): Promise<boolean>;
+}
 /**
  * Core workflow definition
  */
@@ -204,7 +151,7 @@ export type WorkflowContext = Record<string, ContextVariable>;
  * Workflows metadata for inspector/CLI (DSL step-based format)
  */
 export type WorkflowsMeta = Record<string, CommonWireMeta & {
-    workflowName: string;
+    name: string;
     steps: WorkflowStepMeta[];
     context?: WorkflowContext;
     dsl?: boolean;
@@ -218,19 +165,19 @@ export interface WorkflowRuntimeMeta {
     /** Workflow name (used as key in registrations) */
     name: string;
     /** Pikku function name (for execution) */
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     /** Source type: 'dsl' (serializable), 'complex' (has inline steps), 'graph' */
-    source?: 'dsl' | 'complex' | 'graph';
+    source: 'dsl' | 'complex' | 'graph';
     /** Optional description */
     description?: string;
     /** Tags for organization */
     tags?: string[];
-    /** Wires - how the workflow is triggered */
-    wires?: WorkflowWires;
     /** Serialized nodes */
     nodes?: Record<string, any>;
     /** Entry node IDs for graph workflows (computed at build time) */
     entryNodeIds?: string[];
+    /** Hash of graph topology (nodes, edges, input mappings) */
+    graphHash?: string;
 }
 /**
  * Unified workflow runtime metadata map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.11.2",
+  "version": "0.12.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -26,35 +26,34 @@
     "./http": "./dist/wirings/http/index.js",
     "./queue": "./dist/wirings/queue/index.js",
     "./scheduler": "./dist/wirings/scheduler/index.js",
+    "./trigger": "./dist/wirings/trigger/index.js",
     "./rpc": "./dist/wirings/rpc/index.js",
     "./mcp": "./dist/wirings/mcp/index.js",
+    "./ai-agent": "./dist/wirings/ai-agent/index.js",
     "./cli": "./dist/wirings/cli/index.js",
     "./cli/channel": "./dist/wirings/cli/channel/index.js",
-    "./forge-node": "./dist/wirings/forge-node/index.js",
+    "./node": "./dist/wirings/node/index.js",
+    "./secret": "./dist/wirings/secret/index.js",
+    "./variable": "./dist/wirings/variable/index.js",
+    "./oauth2": "./dist/wirings/oauth2/index.js",
     "./errors": "./dist/errors/index.js",
     "./services": "./dist/services/index.js",
     "./services/local-content": "./dist/services/local-content.js",
-    "./schema": "./dist/schema.js",
-    "./types": "./dist/types/index.d.ts"
+    "./services/gopass-secrets": "./dist/services/gopass-secrets.js",
+    "./internal": "./dist/internal.js",
+    "./schema": "./dist/schema.js"
   },
   "dependencies": {
-    "cookie": "^1.0.2",
+    "@standard-schema/spec": "^1.1.0",
+    "cookie": "^1.1.1",
     "path-to-regexp": "^8.3.0",
     "picoquery": "^2.5.0"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1",
-    "tsx": "^4.20.6",
+    "@types/node": "^24.10.12",
+    "tsx": "^4.21.0",
     "typescript": "^5.9"
   },
-  "peerDependencies": {
-    "zod": "^4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "zod": {
-      "optional": true
-    }
-  },
   "engines": {
     "node": ">=18"
   }

package/run-tests.sh

@@ -34,6 +34,9 @@ files=($(find src -type f -name "*.test.ts"))
 # Check if any files matched the pattern
 if [ ${#files[@]} -eq 0 ]; then
   echo "No test files found matching pattern: $pattern"
+  if [ "${STRICT_TEST_DISCOVERY}" = "1" ] || [ "${CI}" = "true" ]; then
+    exit 1
+  fi
   exit 0
 fi
 
@@ -50,4 +53,4 @@ if [ "$coverage_mode" = true ]; then
 fi
 
 # Execute the node command with the expanded list of files
-$node_cmd "${files[@]}"
+$node_cmd "${files[@]}"

package/src/crypto-utils.test.ts

@@ -0,0 +1,116 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { encryptJSON, decryptJSON } from './crypto-utils.js'
+
+describe('encryptJSON / decryptJSON', () => {
+  const secret = 'test-secret-key-for-encryption'
+
+  test('should round-trip a simple object', async () => {
+    const original = { hello: 'world', num: 42 }
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.deepStrictEqual(decrypted, original)
+  })
+
+  test('should round-trip a string value', async () => {
+    const original = 'just a string'
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.strictEqual(decrypted, original)
+  })
+
+  test('should round-trip a number', async () => {
+    const original = 12345
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.strictEqual(decrypted, original)
+  })
+
+  test('should round-trip null', async () => {
+    const encrypted = await encryptJSON(secret, null)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.strictEqual(decrypted, null)
+  })
+
+  test('should round-trip a boolean', async () => {
+    const encrypted = await encryptJSON(secret, true)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.strictEqual(decrypted, true)
+  })
+
+  test('should round-trip a nested object', async () => {
+    const original = { user: { id: 1, roles: ['admin', 'user'] }, active: true }
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.deepStrictEqual(decrypted, original)
+  })
+
+  test('should round-trip an array', async () => {
+    const original = [1, 'two', { three: 3 }]
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.deepStrictEqual(decrypted, original)
+  })
+
+  test('should produce different ciphertexts for same input (random IV)', async () => {
+    const value = { same: 'data' }
+    const enc1 = await encryptJSON(secret, value)
+    const enc2 = await encryptJSON(secret, value)
+    assert.notStrictEqual(enc1, enc2)
+  })
+
+  test('should produce a base64url string (no +, /, or = characters)', async () => {
+    const encrypted = await encryptJSON(secret, { test: 'base64url' })
+    assert.ok(!/[+/=]/.test(encrypted), `Expected base64url, got: ${encrypted}`)
+  })
+
+  test('should fail to decrypt with wrong secret', async () => {
+    const encrypted = await encryptJSON(secret, { data: 'sensitive' })
+    await assert.rejects(
+      () => decryptJSON('wrong-secret', encrypted),
+      (err: any) => err instanceof Error
+    )
+  })
+
+  test('should reject an invalid encrypted payload (too short)', async () => {
+    await assert.rejects(() => decryptJSON(secret, 'dG9vc2hvcnQ'), {
+      message: 'Invalid encrypted payload',
+    })
+  })
+
+  test('should reject empty string', async () => {
+    await assert.rejects(() => decryptJSON(secret, ''), {
+      message: 'Invalid encrypted payload',
+    })
+  })
+
+  test('should reject corrupted ciphertext', async () => {
+    const encrypted = await encryptJSON(secret, { data: 'test' })
+    const corrupted = encrypted.slice(0, -4) + 'XXXX'
+    await assert.rejects(
+      () => decryptJSON(secret, corrupted),
+      (err: any) => err instanceof Error
+    )
+  })
+
+  test('should handle unicode content', async () => {
+    const original = { emoji: '🎉', japanese: 'こんにちは', arabic: 'مرحبا' }
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.deepStrictEqual(decrypted, original)
+  })
+
+  test('should handle empty object', async () => {
+    const original = {}
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.deepStrictEqual(decrypted, original)
+  })
+
+  test('should handle large payload', async () => {
+    const original = { data: 'x'.repeat(10000) }
+    const encrypted = await encryptJSON(secret, original)
+    const decrypted = await decryptJSON(secret, encrypted)
+    assert.deepStrictEqual(decrypted, original)
+  })
+})

package/src/crypto-utils.ts

@@ -0,0 +1,99 @@
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
+const getSubtle = () => {
+  const crypto = globalThis.crypto
+  if (!crypto?.subtle) {
+    throw new Error('WebCrypto not available')
+  }
+  return crypto.subtle
+}
+
+const base64Encode = (bytes: Uint8Array): string => {
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(bytes).toString('base64')
+  }
+  let binary = ''
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]!)
+  }
+  return btoa(binary)
+}
+
+const base64Decode = (input: string): Uint8Array => {
+  if (typeof Buffer !== 'undefined') {
+    return new Uint8Array(Buffer.from(input, 'base64'))
+  }
+  const binary = atob(input)
+  const bytes = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i)
+  }
+  return bytes
+}
+
+const toBase64Url = (bytes: Uint8Array): string => {
+  return base64Encode(bytes)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '')
+}
+
+const fromBase64Url = (input: string): Uint8Array => {
+  let base64 = input.replace(/-/g, '+').replace(/_/g, '/')
+  while (base64.length % 4 !== 0) base64 += '='
+  return base64Decode(base64)
+}
+
+const deriveKey = async (secret: string): Promise<CryptoKey> => {
+  const subtle = getSubtle()
+  const hash = await subtle.digest('SHA-256', encoder.encode(secret))
+  return subtle.importKey('raw', hash, { name: 'AES-GCM' }, false, [
+    'encrypt',
+    'decrypt',
+  ])
+}
+
+export const encryptJSON = async (
+  secret: string,
+  value: unknown
+): Promise<string> => {
+  const crypto = globalThis.crypto
+  if (!crypto?.getRandomValues) {
+    throw new Error('WebCrypto not available')
+  }
+  const subtle = getSubtle()
+  const iv = crypto.getRandomValues(new Uint8Array(12))
+  const key = await deriveKey(secret)
+  const plaintext = encoder.encode(JSON.stringify(value))
+  const encrypted = await subtle.encrypt(
+    { name: 'AES-GCM', iv },
+    key,
+    plaintext
+  )
+  const cipherBytes = new Uint8Array(encrypted)
+  const out = new Uint8Array(iv.length + cipherBytes.length)
+  out.set(iv, 0)
+  out.set(cipherBytes, iv.length)
+  return toBase64Url(out)
+}
+
+export const decryptJSON = async <T>(
+  secret: string,
+  token: string
+): Promise<T> => {
+  const subtle = getSubtle()
+  const data = fromBase64Url(token)
+  if (data.length < 13) {
+    throw new Error('Invalid encrypted payload')
+  }
+  const iv = data.slice(0, 12)
+  const ciphertext = data.slice(12)
+  const key = await deriveKey(secret)
+  const decrypted = await subtle.decrypt(
+    { name: 'AES-GCM', iv },
+    key,
+    ciphertext
+  )
+  return JSON.parse(decoder.decode(new Uint8Array(decrypted))) as T
+}

package/src/errors/error.test.ts

@@ -1,7 +1,75 @@
 import { test, describe } from 'node:test'
 import assert from 'assert'
-import { getErrorResponse, addError } from './error-handler.js'
-import { ForbiddenError, BadRequestError, NotFoundError } from './errors.js'
+import {
+  getErrorResponse,
+  addError,
+  addErrors,
+  PikkuError,
+} from './error-handler.js'
+import {
+  BadRequestError,
+  UnauthorizedError,
+  MissingSessionError,
+  InvalidSessionError,
+  PaymentRequiredError,
+  ForbiddenError,
+  InvalidOriginError,
+  NotFoundError,
+  MethodNotAllowedError,
+  NotAcceptableError,
+  ProxyAuthenticationRequiredError,
+  RequestTimeoutError,
+  ConflictError,
+  GoneError,
+  LengthRequiredError,
+  PreconditionFailedError,
+  PayloadTooLargeError,
+  URITooLongError,
+  UnsupportedMediaTypeError,
+  RangeNotSatisfiableError,
+  ExpectationFailedError,
+  UnprocessableContentError,
+  LockedError,
+  TooManyRequestsError,
+  InternalServerError,
+  NotImplementedError,
+  BadGatewayError,
+  ServiceUnavailableError,
+  GatewayTimeoutError,
+  HTTPVersionNotSupportedError,
+  MaxComputeTimeReachedError,
+  MissingSchemaError,
+  InvalidMiddlewareWireError,
+  PikkuMissingMetaError,
+} from './errors.js'
+
+describe('PikkuError', () => {
+  test('should create error with default message', () => {
+    const error = new PikkuError()
+    assert.strictEqual(error.message, 'An error occurred')
+  })
+
+  test('should create error with custom message', () => {
+    const error = new PikkuError('custom message')
+    assert.strictEqual(error.message, 'custom message')
+  })
+
+  test('should be instance of Error', () => {
+    const error = new PikkuError()
+    assert.ok(error instanceof Error)
+  })
+
+  test('should be instance of PikkuError', () => {
+    const error = new PikkuError()
+    assert.ok(error instanceof PikkuError)
+  })
+
+  test('subclasses should be instanceof PikkuError', () => {
+    assert.ok(new BadRequestError() instanceof PikkuError)
+    assert.ok(new NotFoundError() instanceof PikkuError)
+    assert.ok(new ForbiddenError() instanceof PikkuError)
+  })
+})
 
 describe('getErrorResponse', () => {
   test('should return the correct error response for BadRequestError', () => {
@@ -52,3 +120,76 @@ describe('getErrorResponse', () => {
     assert.deepStrictEqual(response, customErrorDetails)
   })
 })
+
+describe('addErrors', () => {
+  test('should register multiple errors at once', () => {
+    class ErrA extends Error {}
+    class ErrB extends Error {}
+    addErrors([
+      [ErrA, { status: 450, message: 'Error A' }],
+      [ErrB, { status: 451, message: 'Error B' }],
+    ])
+    assert.deepStrictEqual(getErrorResponse(new ErrA()), {
+      status: 450,
+      message: 'Error A',
+    })
+    assert.deepStrictEqual(getErrorResponse(new ErrB()), {
+      status: 451,
+      message: 'Error B',
+    })
+  })
+})
+
+describe('all built-in error classes', () => {
+  const errorCases: [string, any, number][] = [
+    ['InvalidMiddlewareWireError', InvalidMiddlewareWireError, 500],
+    ['PikkuMissingMetaError', PikkuMissingMetaError, 500],
+    ['BadRequestError', BadRequestError, 400],
+    ['UnauthorizedError', UnauthorizedError, 401],
+    ['MissingSessionError', MissingSessionError, 401],
+    ['InvalidSessionError', InvalidSessionError, 401],
+    ['PaymentRequiredError', PaymentRequiredError, 402],
+    ['ForbiddenError', ForbiddenError, 403],
+    ['InvalidOriginError', InvalidOriginError, 403],
+    ['NotFoundError', NotFoundError, 404],
+    ['MethodNotAllowedError', MethodNotAllowedError, 405],
+    ['NotAcceptableError', NotAcceptableError, 406],
+    ['ProxyAuthenticationRequiredError', ProxyAuthenticationRequiredError, 407],
+    ['RequestTimeoutError', RequestTimeoutError, 408],
+    ['ConflictError', ConflictError, 409],
+    ['GoneError', GoneError, 410],
+    ['LengthRequiredError', LengthRequiredError, 411],
+    ['PreconditionFailedError', PreconditionFailedError, 412],
+    ['PayloadTooLargeError', PayloadTooLargeError, 413],
+    ['URITooLongError', URITooLongError, 414],
+    ['UnsupportedMediaTypeError', UnsupportedMediaTypeError, 415],
+    ['RangeNotSatisfiableError', RangeNotSatisfiableError, 416],
+    ['ExpectationFailedError', ExpectationFailedError, 417],
+    ['UnprocessableContentError', UnprocessableContentError, 422],
+    ['LockedError', LockedError, 423],
+    ['TooManyRequestsError', TooManyRequestsError, 429],
+    ['InternalServerError', InternalServerError, 500],
+    ['NotImplementedError', NotImplementedError, 501],
+    ['BadGatewayError', BadGatewayError, 502],
+    ['ServiceUnavailableError', ServiceUnavailableError, 503],
+    ['GatewayTimeoutError', GatewayTimeoutError, 504],
+    ['HTTPVersionNotSupportedError', HTTPVersionNotSupportedError, 505],
+    ['MaxComputeTimeReachedError', MaxComputeTimeReachedError, 524],
+    ['MissingSchemaError', MissingSchemaError, 500],
+  ]
+
+  for (const [name, ErrorClass, expectedStatus] of errorCases) {
+    test(`${name} should map to status ${expectedStatus}`, () => {
+      const error = new ErrorClass()
+      const response = getErrorResponse(error)
+      assert.ok(response, `Expected error response for ${name}`)
+      assert.strictEqual(response!.status, expectedStatus)
+      assert.ok(response!.message.length > 0)
+    })
+
+    test(`${name} should be instance of PikkuError`, () => {
+      const error = new ErrorClass()
+      assert.ok(error instanceof PikkuError)
+    })
+  }
+})

package/src/errors/errors.ts

@@ -9,6 +9,12 @@ addError(InvalidMiddlewareWireError, {
   message: 'The middleware wire is invalid for the current wiring type.',
 })
 
+export class PikkuMissingMetaError extends PikkuError {}
+addError(PikkuMissingMetaError, {
+  status: 500,
+  message: 'Required metadata is missing',
+})
+
 /**
  * The server cannot or will not process the request due to client error (e.g., malformed request syntax).
  * @group Error
@@ -70,6 +76,16 @@ addError(ForbiddenError, {
     'The client does not have permission to access the requested resource.',
 })
 
+/**
+ * The session is readonly and cannot access a non-readonly function.
+ * @group Error
+ */
+export class ReadonlySessionError extends PikkuError {}
+addError(ReadonlySessionError, {
+  status: 403,
+  message: 'The session is readonly and cannot access this function.',
+})
+
 /**
  * The request was made from an origin that is not permitted to access this resource.
  * @group Error
@@ -345,3 +361,14 @@ addError(MaxComputeTimeReachedError, {
   message:
     'The server took too long to complete the request, reaching the maximum compute time allowed.',
 })
+
+/**
+ * A required schema was not found during validation.
+ * @group Error
+ */
+export class MissingSchemaError extends PikkuError {}
+addError(MissingSchemaError, {
+  status: 500,
+  message:
+    'A required schema was not found. Ensure schema generation has been run.',
+})

package/src/errors/index.ts

@@ -1,2 +1,2 @@
-export * from './error-handler.js'
 export * from './errors.js'
+export { PikkuError, addError, addErrors } from './error-handler.js'