@trigora/sdk 0.9.0 → 1.0.0

package/README.md

@@ -1,8 +1,8 @@
 # @trigora/sdk
 
-Flow authoring for Trigora.
+TypeScript authoring SDK for Trigora durable programs.
 
-`@trigora/sdk` is the package most Trigora users write against directly. It provides `defineFlow` plus the shared runtime types needed to author flows with good TypeScript ergonomics.
+Build long-running programs that can call external systems, wait for events, sleep durably, invoke child executions, and recover from committed continuation state.
 
 ## Install
 
@@ -10,314 +10,105 @@ Flow authoring for Trigora.
 npm install @trigora/sdk
 ```
 
-Most projects will install the CLI alongside it:
-
-```bash
-npm install trigora @trigora/sdk
-```
-
-## Basic Usage
+## Quick example
 
 ```ts
-import { defineFlow } from '@trigora/sdk';
-
-export default defineFlow({
-  id: 'hello',
-  trigger: { type: 'manual' },
-  async run(event, ctx) {
-    await ctx.log.info('Hello from Trigora', event.payload);
-  },
-});
-```
-
-## What `defineFlow` Gives You
-
-`defineFlow` helps with:
-
-- typed flow definitions
-- typed trigger variants
-- typed event payload access
-- typed runtime context
-- trigger-aware return types
-- compile-time validation of trigger shape
+import { effect, waitForEvent } from '@trigora/sdk';
 
-The trigger typing is strict. If you mix properties from different trigger kinds, TypeScript will flag it.
+export default async function approval(input) {
+  const result = await effect('generate', () => 42);
+  const review = await waitForEvent('approved');
 
-For example, this is invalid:
-
-```ts
-import { defineFlow } from '@trigora/sdk';
-
-export default defineFlow({
-  id: 'broken',
-  trigger: {
-    type: 'webhook',
-    cron: '* * * * *',
-  },
-  async run() {
-    return 'nope';
-  },
-});
+  return { result, review };
+}
 ```
 
-## Trigger Types
-
-### Manual
-
-Use manual triggers for local invocation and testing.
+Run it locally with:
 
-```ts
-import { defineFlow } from '@trigora/sdk';
-
-export default defineFlow({
-  id: 'hello',
-  trigger: { type: 'manual' },
-  async run(event, ctx) {
-    await ctx.log.info('Triggered manually', event.payload);
-  },
-});
+```bash
+trigora dev
+trigora start approval --input '{"request":"example"}'
 ```
 
-### Webhook
+## Program entry
 
-Use webhook triggers for hosted HTTP entrypoints.
+Trigora discovers programs from the paths configured in `trigora.toml`:
 
-```ts
-import { defineFlow } from '@trigora/sdk';
-
-export default defineFlow({
-  id: 'stripe-webhook',
-  trigger: { type: 'webhook', route: '/hooks/stripe' },
-  async run() {
-    return 'pong';
-  },
-});
+```toml
+[project]
+name = "my-project"
+programs = ["src/**/*.ts"]
 ```
 
-`id` is the internal flow identifier used by the CLI. `route` is the optional public hosted webhook path.
-When `route` is omitted, hosted ingress defaults to `/${id}`.
-
-You can also include an optional event name:
+Each matching file default-exports one async program entry.
 
 ```ts
-trigger: { type: 'webhook', event: 'orders.created', route: '/hooks/orders' }
+export default async function research(topic, depth = topic) {
+  // ...
+}
 ```
 
-### Cron
-
-Use cron triggers for scheduled work.
-
-```ts
-import { defineFlow } from '@trigora/sdk';
-
-export default defineFlow({
-  id: 'nightly-sync',
-  trigger: { type: 'cron', cron: '0 2 * * *' },
-  async run(event, ctx) {
-    await ctx.log.info('Nightly sync started', event.payload);
-  },
-});
-```
+The TypeScript frontend implements `ts.subset.v1`.
 
-### Queue
+Program parameters may be plain identifiers. Defaults may reference earlier parameters only. Missing arguments remain `undefined` unless a supported default applies, and extra arguments are ignored.
 
-Use queue triggers to consume workspace-scoped queue messages. Deploy auto-provisions and binds the named queue to the flow.
+Rest parameters and optional `?` parameters are not supported.
 
-Optional `retry` configures how many times a failed message may be redelivered. Omitted `retry` means a single attempt. `attempts > 1` is supported for queue flows only.
+An anonymous default export is also valid:
 
 ```ts
-import { defineFlow } from '@trigora/sdk';
-
-export default defineFlow({
-  id: 'process-image',
-  trigger: { type: 'queue', queue: 'image-processing' },
-  retry: { attempts: 5, backoff: 'exponential' },
-  async run(event, ctx) {
-    await ctx.log.info('Processing message', {
-      queue: event.queue,
-      messageId: event.messageId,
-      attempt: event.attempt,
-      maxAttempts: event.maxAttempts,
-      payload: event.payload,
-    });
-  },
-});
+export default async function () {
+  // ...
+}
 ```
 
-Locally, `trigora trigger` and `trigora dev` invoke queue flows with a synthetic `QueueFlowEvent` (`messageId` starts with `local_`, `attempt` is `1`, and `maxAttempts` comes from `retry.attempts` or `1`). Local runs do not actually retry. Hosted runs use the real message id and attempt count.
-
-## Return Types
-
-Return values are trigger-aware.
-
-### Webhook flows
-
-Webhook flows can return HTTP-friendly values directly from `run`.
-
-Supported return values:
-
-- `Response`
-- plain objects, arrays, numbers, and booleans
-- `string`
-- `null`
-- `undefined`
-
-Example:
-
-```ts
-import { defineFlow } from '@trigora/sdk';
-
-export default defineFlow({
-  id: 'status',
-  trigger: { type: 'webhook', route: '/status' },
-  async run() {
-    return {
-      ok: true,
-      service: 'trigora',
-    };
-  },
-});
-```
+Its artifact entry name is `"default"`.
 
-### Manual, cron, and queue flows
+## Durable primitives
 
-Manual, cron, and queue flows do not use return values. Their `run` functions are typed as `void`.
+- `effect(name, fn)` — run a durable external effect
+- `sleep(ms)` — suspend on a durable timer
+- `waitForEvent(name)` — wait for an external event
+- `invoke(program, input)` — invoke a durable child execution
+- `execution.id` — current execution id
+- `execution.attempt` — current attempt
+- `execution.signal` — execution cancellation signal
 
-This matches how Trigora uses them:
+Effect keys and event names are string literals in the current TypeScript subset.
 
-- manual flows are invoked locally for testing and development
-- cron flows are background-style scheduled jobs
-- queue flows consume workspace queue messages
-- webhook flows are request-response flows
+## Local development
 
-## Event Shape
-
-Flows receive an event object:
-
-```ts
-type FlowEvent<TPayload = JsonValue> = {
-  id: string;
-  type: string;
-  timestamp: string;
-  payload: TPayload;
-  request?: {
-    headers: Record<string, string>;
-    method: string;
-    url: string;
-    rawBody: string;
-  };
-};
-```
-
-Queue events also include:
-
-```ts
-queue: string;
-messageId: string;
-attempt: number;      // 1-based delivery count
-maxAttempts: number;  // from retry.attempts, or 1 when omitted
-```
-
-In local manual runs, the payload comes from your JSON payload file when one is provided. In local webhook dev and deployed webhook flows, the payload is the parsed JSON request body.
-
-If you do not provide your own payload type, `event.payload` defaults to `JsonValue`.
-
-For webhook flows, request metadata may also be available on `event.request`, including headers, method, URL, and the raw request body. `event.request.rawBody` is useful when you want to verify webhook signatures yourself.
-
-## Stripe Webhooks
-
-Trigora includes a small helper for verifying Stripe webhook signatures:
-
-```ts
-import { defineFlow } from '@trigora/sdk';
-import { verifyStripeWebhook } from '@trigora/sdk/stripe';
-
-export default defineFlow({
-  id: 'stripe-webhook',
-  trigger: { type: 'webhook', route: '/hooks/stripe' },
-  async run(event, ctx) {
-    await verifyStripeWebhook(event, {
-      secret: ctx.env.STRIPE_WEBHOOK_SECRET,
-    });
-
-    return { ok: true };
-  },
-});
+```bash
+trigora init
+trigora dev
+trigora start approval
+trigora send <execution> approved --payload '"ok"'
+trigora result <execution>
 ```
 
-This verifies against `event.request.rawBody` and the `Stripe-Signature` header.
-
-Production Stripe webhooks should verify signatures before trusting payloads.
+Programs execute through the Trigora runtime rather than by running the source file directly.
 
-## GitHub Webhooks
+## Typed events
 
-Trigora includes a small helper for verifying GitHub webhook signatures:
+`event()` can be used to define typed events shared between program and client code.
 
-```ts
-import { defineFlow } from '@trigora/sdk';
-import { verifyGitHubWebhook } from '@trigora/sdk/github';
-
-export default defineFlow({
-  id: 'github-webhook',
-  trigger: { type: 'webhook', route: '/hooks/github' },
-  async run(event, ctx) {
-    await verifyGitHubWebhook(event, {
-      secret: ctx.env.GITHUB_WEBHOOK_SECRET,
-    });
-
-    return { ok: true };
-  },
-});
-```
+## Integrations
 
-This verifies against `event.request.rawBody` and the `X-Hub-Signature-256` header.
-
-## Context
-
-Flows receive a context object with logging and environment access:
+Webhook signature helpers are available at:
 
 ```ts
-ctx.log.info('message')
-ctx.log.warn('message')
-ctx.log.error('message')
-
-ctx.env
+@trigora/sdk/stripe
+@trigora/sdk/github
 ```
 
-In local CLI runs, `ctx.env` includes the process environment after loading `.env` and `.env.local`, with existing shell variables taking precedence.
-
-The exact exported type is `FlowContext<TEnv>`.
-
-## Exported Types
-
-`@trigora/sdk` re-exports the main flow authoring types from `@trigora/contracts`:
-
-- `FlowContext`
-- `FlowDefinition`
-- `FlowEvent`
-- `FlowRunFn`
-- `JsonValue`
-- `RetryPolicy`
-- `Trigger`
-- `WebhookFlowResult`
-
-That means most flow authors can stay entirely within `@trigora/sdk`.
-
-## Typical Workflow
-
-1. Define a flow with `defineFlow`
-2. Run it locally with:
-   - `trigora trigger hello --payload payload.json` for one-off runs
-   - `trigora dev hello --payload payload.json` for manual or payload watch mode
-   - `trigora dev stripe-checkout` for a local webhook server
-3. Deploy webhook flows with `trigora deploy`
-4. Manage hosted flows with `trigora flows`
+These are optional TypeScript convenience utilities.
 
-## Related Packages
+## Learn more
 
-- `trigora` - CLI for local development and hosted deploys
-- `@trigora/contracts` - shared public types used by the SDK, CLI, and API consumers
+- [Quickstart](https://trigora.dev/docs/quickstart)
+- [Trigora documentation](https://trigora.dev/docs)
+- [TCC TypeScript semantics](https://github.com/trigora-dev/tcc-engine/blob/main/spec/typescript-subset.md)
 
 ## License
 
-MIT
+MIT © 2026 Trigora, Inc.

package/dist/chunk-6GNCTPSN.js

@@ -0,0 +1,70 @@
+// src/webhookSignature.ts
+function encodeUtf8(value) {
+  return new TextEncoder().encode(value);
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function getHeaderCaseInsensitive(headers, headerName) {
+  const normalizedName = headerName.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === normalizedName) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function isHexString(value) {
+  return value.length > 0 && value.length % 2 === 0 && /^[0-9a-f]+$/i.test(value);
+}
+function timingSafeEqualStrings(left, right) {
+  const leftBytes = encodeUtf8(left);
+  const rightBytes = encodeUtf8(right);
+  const length = Math.max(leftBytes.length, rightBytes.length);
+  let difference = leftBytes.length === rightBytes.length ? 0 : 1;
+  for (let index = 0; index < length; index += 1) {
+    difference |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
+  }
+  return difference === 0;
+}
+async function computeHmacSha256Hex(secret, signedPayload) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error("Web Crypto API is unavailable in this runtime.");
+  }
+  const key = await subtle.importKey(
+    "raw",
+    toArrayBuffer(encodeUtf8(secret)),
+    {
+      name: "HMAC",
+      hash: "SHA-256"
+    },
+    false,
+    ["sign"]
+  );
+  const signature = await subtle.sign("HMAC", key, toArrayBuffer(encodeUtf8(signedPayload)));
+  return bytesToHex(new Uint8Array(signature));
+}
+function requireWebhookRequestParts(event, providerName) {
+  if (!event.request || typeof event.request.headers !== "object" || event.request.headers === null) {
+    throw new Error(`${providerName} webhook request metadata is required.`);
+  }
+  if (typeof event.request.rawBody !== "string") {
+    throw new Error(`${providerName} webhook raw body is required.`);
+  }
+  return {
+    headers: event.request.headers,
+    rawBody: event.request.rawBody
+  };
+}
+
+export {
+  getHeaderCaseInsensitive,
+  isHexString,
+  timingSafeEqualStrings,
+  computeHmacSha256Hex,
+  requireWebhookRequestParts
+};

package/dist/chunk-JYNY75DO.js

@@ -0,0 +1,20 @@
+// src/runtimeHost.ts
+import { AsyncLocalStorage } from "async_hooks";
+var runtimeStorage = new AsyncLocalStorage();
+function runWithDurableRuntime(host, fn) {
+  return runtimeStorage.run(host, fn);
+}
+function getDurableRuntimeHost() {
+  const host = runtimeStorage.getStore();
+  if (!host) {
+    throw new Error(
+      "Durable primitives can only run inside a Trigora execution. Start the program with `@trigora/client` while `trigora dev` is running."
+    );
+  }
+  return host;
+}
+
+export {
+  runWithDurableRuntime,
+  getDurableRuntimeHost
+};

package/dist/effect.d.ts

@@ -0,0 +1 @@
+export declare function effect<T>(name: string, run: () => T | Promise<T>): Promise<T>;

package/dist/event.d.ts

@@ -0,0 +1,4 @@
+import { resolveEventName, type EventDefinition } from '@trigora/contracts';
+export type { EventDefinition };
+export { resolveEventName };
+export declare function event<TPayload = unknown>(name: string): EventDefinition<TPayload>;

package/dist/execution.d.ts

@@ -0,0 +1,3 @@
+import { type ExecutionInfo } from './runtimeHost';
+export type { ExecutionInfo };
+export declare const execution: ExecutionInfo;

package/dist/github.d.ts

@@ -1,8 +1,8 @@
-import type { WebhookFlowEvent } from '@trigora/contracts';
+import type { WebhookRequest } from './webhookSignature';
 export type VerifyGitHubWebhookOptions = {
     secret: string | undefined;
 };
 export declare class GitHubWebhookVerificationError extends Error {
     name: string;
 }
-export declare function verifyGitHubWebhook<T = unknown>(event: WebhookFlowEvent, options: VerifyGitHubWebhookOptions): Promise<T>;
+export declare function verifyGitHubWebhook<T = unknown>(event: WebhookRequest, options: VerifyGitHubWebhookOptions): Promise<T>;

package/dist/github.js

@@ -1,65 +1,10 @@
-// src/webhookSignature.ts
-function encodeUtf8(value) {
-  return new TextEncoder().encode(value);
-}
-function toArrayBuffer(bytes) {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function bytesToHex(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function getHeaderCaseInsensitive(headers, headerName) {
-  const normalizedName = headerName.toLowerCase();
-  for (const [key, value] of Object.entries(headers)) {
-    if (key.toLowerCase() === normalizedName) {
-      return value;
-    }
-  }
-  return void 0;
-}
-function isHexString(value) {
-  return value.length > 0 && value.length % 2 === 0 && /^[0-9a-f]+$/i.test(value);
-}
-function timingSafeEqualStrings(left, right) {
-  const leftBytes = encodeUtf8(left);
-  const rightBytes = encodeUtf8(right);
-  const length = Math.max(leftBytes.length, rightBytes.length);
-  let difference = leftBytes.length === rightBytes.length ? 0 : 1;
-  for (let index = 0; index < length; index += 1) {
-    difference |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
-  }
-  return difference === 0;
-}
-async function computeHmacSha256Hex(secret, signedPayload) {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    throw new Error("Web Crypto API is unavailable in this runtime.");
-  }
-  const key = await subtle.importKey(
-    "raw",
-    toArrayBuffer(encodeUtf8(secret)),
-    {
-      name: "HMAC",
-      hash: "SHA-256"
-    },
-    false,
-    ["sign"]
-  );
-  const signature = await subtle.sign("HMAC", key, toArrayBuffer(encodeUtf8(signedPayload)));
-  return bytesToHex(new Uint8Array(signature));
-}
-function requireWebhookRequestParts(event, providerName) {
-  if (!event.request || typeof event.request.headers !== "object" || event.request.headers === null) {
-    throw new Error(`${providerName} webhook request metadata is required.`);
-  }
-  if (typeof event.request.rawBody !== "string") {
-    throw new Error(`${providerName} webhook raw body is required.`);
-  }
-  return {
-    headers: event.request.headers,
-    rawBody: event.request.rawBody
-  };
-}
+import {
+  computeHmacSha256Hex,
+  getHeaderCaseInsensitive,
+  isHexString,
+  requireWebhookRequestParts,
+  timingSafeEqualStrings
+} from "./chunk-6GNCTPSN.js";
 
 // src/github.ts
 var GITHUB_SIGNATURE_HEADER = "x-hub-signature-256";

package/dist/index.d.ts

@@ -1,2 +1,13 @@
-export { defineFlow } from './defineFlow';
-export type { CronEventPayload, CronFlowEvent, FlowContext, FlowDefinition, FlowEvent, FlowRunFn, JsonValue, ManualFlowEvent, QueueFlowEvent, RetryBackoff, RetryPolicy, Trigger, WebhookFlowEvent, WebhookFlowResult, } from '@trigora/contracts';
+export { effect } from './effect';
+export { event, resolveEventName } from './event';
+export { execution } from './execution';
+export { invoke } from './invoke';
+export { resolveProgramId } from './program';
+export { sleep } from './sleep';
+export { waitForEvent } from './waitForEvent';
+export type { EventDefinition } from './event';
+export type { ExecutionInfo } from './execution';
+export type { DurableProgram } from './program';
+export type { DurableRuntimeHost } from './runtimeHost';
+export type { WaitForEventOptions } from './waitForEvent';
+export type { ArtifactIdentity, Execution, ExecutionStatus, ExecutionWait, JsonValue, ProgramIdentity, } from '@trigora/contracts';

package/dist/index.js

@@ -1,7 +1,68 @@
-// src/defineFlow.ts
-function defineFlow(flow) {
-  return flow;
+import {
+  getDurableRuntimeHost
+} from "./chunk-JYNY75DO.js";
+
+// src/effect.ts
+function effect(name, run) {
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new Error("effect(name, fn) requires a non-empty string key.");
+  }
+  if (typeof run !== "function") {
+    throw new Error("effect(name, fn) requires a function.");
+  }
+  return getDurableRuntimeHost().effect(name, run);
+}
+
+// src/event.ts
+import { resolveEventName } from "@trigora/contracts";
+function event(name) {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new Error("Event name must be a non-empty string.");
+  }
+  return { name: trimmed };
+}
+
+// src/execution.ts
+var execution = {
+  get id() {
+    return getDurableRuntimeHost().getExecution().id;
+  },
+  get attempt() {
+    return getDurableRuntimeHost().getExecution().attempt;
+  },
+  get programId() {
+    return getDurableRuntimeHost().getExecution().programId;
+  },
+  get signal() {
+    return getDurableRuntimeHost().getExecution().signal;
+  }
+};
+
+// src/program.ts
+import { resolveProgramId } from "@trigora/contracts";
+
+// src/invoke.ts
+function invoke(program, input) {
+  return getDurableRuntimeHost().invoke(resolveProgramId(program), input);
+}
+
+// src/sleep.ts
+function sleep(duration) {
+  return getDurableRuntimeHost().sleep(duration);
+}
+
+// src/waitForEvent.ts
+function waitForEvent(eventOrName, options) {
+  return getDurableRuntimeHost().waitForEvent(resolveEventName(eventOrName), options);
 }
 export {
-  defineFlow
+  effect,
+  event,
+  execution,
+  invoke,
+  resolveEventName,
+  resolveProgramId,
+  sleep,
+  waitForEvent
 };

package/dist/invoke.d.ts

@@ -0,0 +1,2 @@
+import type { DurableProgram } from './program';
+export declare function invoke<TInput, TResult>(program: DurableProgram<TInput, TResult> | string, input: TInput): Promise<TResult>;

package/dist/program.d.ts

@@ -0,0 +1 @@
+export { resolveProgramId, type DurableProgram } from '@trigora/contracts';

package/dist/runtime.d.ts

@@ -0,0 +1 @@
+export { getDurableRuntimeHost, runWithDurableRuntime, type DurableRuntimeHost, type ExecutionInfo, } from './runtimeHost';

package/dist/runtime.js

@@ -0,0 +1,8 @@
+import {
+  getDurableRuntimeHost,
+  runWithDurableRuntime
+} from "./chunk-JYNY75DO.js";
+export {
+  getDurableRuntimeHost,
+  runWithDurableRuntime
+};

package/dist/runtimeHost.d.ts

@@ -0,0 +1,17 @@
+import type { JsonValue, WaitForEventOptions } from '@trigora/contracts';
+export type ExecutionInfo = {
+    id: string;
+    attempt: number;
+    programId: string;
+    signal: AbortSignal;
+};
+export type DurableRuntimeHost = {
+    effect<T>(name: string, run: () => T | Promise<T>): Promise<T>;
+    sleep(duration: string | number): Promise<void>;
+    waitForEvent<T>(name: string, options?: WaitForEventOptions): Promise<T>;
+    invoke<TInput, TResult>(programId: string, input: TInput): Promise<TResult>;
+    getExecution(): ExecutionInfo;
+};
+export declare function runWithDurableRuntime<T>(host: DurableRuntimeHost, fn: () => Promise<T>): Promise<T>;
+export declare function getDurableRuntimeHost(): DurableRuntimeHost;
+export type { JsonValue, WaitForEventOptions };

package/dist/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(duration: string | number): Promise<void>;

package/dist/stripe.d.ts

@@ -1,4 +1,4 @@
-import type { WebhookFlowEvent } from '@trigora/contracts';
+import type { WebhookRequest } from './webhookSignature';
 export type VerifyStripeWebhookOptions = {
     secret: string | undefined;
     toleranceSeconds?: number;
@@ -6,4 +6,4 @@ export type VerifyStripeWebhookOptions = {
 export declare class StripeWebhookVerificationError extends Error {
     name: string;
 }
-export declare function verifyStripeWebhook<T = unknown>(event: WebhookFlowEvent, options: VerifyStripeWebhookOptions): Promise<T>;
+export declare function verifyStripeWebhook<T = unknown>(event: WebhookRequest, options: VerifyStripeWebhookOptions): Promise<T>;

package/dist/stripe.js

@@ -1,65 +1,10 @@
-// src/webhookSignature.ts
-function encodeUtf8(value) {
-  return new TextEncoder().encode(value);
-}
-function toArrayBuffer(bytes) {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function bytesToHex(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function getHeaderCaseInsensitive(headers, headerName) {
-  const normalizedName = headerName.toLowerCase();
-  for (const [key, value] of Object.entries(headers)) {
-    if (key.toLowerCase() === normalizedName) {
-      return value;
-    }
-  }
-  return void 0;
-}
-function isHexString(value) {
-  return value.length > 0 && value.length % 2 === 0 && /^[0-9a-f]+$/i.test(value);
-}
-function timingSafeEqualStrings(left, right) {
-  const leftBytes = encodeUtf8(left);
-  const rightBytes = encodeUtf8(right);
-  const length = Math.max(leftBytes.length, rightBytes.length);
-  let difference = leftBytes.length === rightBytes.length ? 0 : 1;
-  for (let index = 0; index < length; index += 1) {
-    difference |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
-  }
-  return difference === 0;
-}
-async function computeHmacSha256Hex(secret, signedPayload) {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    throw new Error("Web Crypto API is unavailable in this runtime.");
-  }
-  const key = await subtle.importKey(
-    "raw",
-    toArrayBuffer(encodeUtf8(secret)),
-    {
-      name: "HMAC",
-      hash: "SHA-256"
-    },
-    false,
-    ["sign"]
-  );
-  const signature = await subtle.sign("HMAC", key, toArrayBuffer(encodeUtf8(signedPayload)));
-  return bytesToHex(new Uint8Array(signature));
-}
-function requireWebhookRequestParts(event, providerName) {
-  if (!event.request || typeof event.request.headers !== "object" || event.request.headers === null) {
-    throw new Error(`${providerName} webhook request metadata is required.`);
-  }
-  if (typeof event.request.rawBody !== "string") {
-    throw new Error(`${providerName} webhook raw body is required.`);
-  }
-  return {
-    headers: event.request.headers,
-    rawBody: event.request.rawBody
-  };
-}
+import {
+  computeHmacSha256Hex,
+  getHeaderCaseInsensitive,
+  isHexString,
+  requireWebhookRequestParts,
+  timingSafeEqualStrings
+} from "./chunk-6GNCTPSN.js";
 
 // src/stripe.ts
 var DEFAULT_TOLERANCE_SECONDS = 300;

package/dist/waitForEvent.d.ts

@@ -0,0 +1,3 @@
+import type { EventDefinition, WaitForEventOptions } from '@trigora/contracts';
+export type { WaitForEventOptions };
+export declare function waitForEvent<TPayload>(eventOrName: EventDefinition<TPayload> | string, options?: WaitForEventOptions): Promise<TPayload>;

package/dist/webhookSignature.d.ts

@@ -1,4 +1,12 @@
-import type { WebhookFlowEvent } from '@trigora/contracts';
+export type WebhookRequest = {
+    request: {
+        headers: Record<string, string>;
+        rawBody: string;
+        method?: string;
+        url?: string;
+    };
+    payload?: unknown;
+};
 export declare function encodeUtf8(value: string): Uint8Array;
 export declare function toArrayBuffer(bytes: Uint8Array): ArrayBuffer;
 export declare function bytesToHex(bytes: Uint8Array): string;
@@ -6,7 +14,7 @@ export declare function getHeaderCaseInsensitive(headers: Record<string, string>
 export declare function isHexString(value: string): boolean;
 export declare function timingSafeEqualStrings(left: string, right: string): boolean;
 export declare function computeHmacSha256Hex(secret: string, signedPayload: string): Promise<string>;
-export declare function requireWebhookRequestParts(event: WebhookFlowEvent, providerName: string): {
+export declare function requireWebhookRequestParts(event: WebhookRequest, providerName: string): {
     headers: Record<string, string>;
     rawBody: string;
 };

package/package.json

@@ -1,25 +1,21 @@
 {
   "name": "@trigora/sdk",
-  "version": "0.9.0",
+  "version": "1.0.0",
+  "description": "TypeScript authoring SDK for Trigora durable programs.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/trigora-dev/trigora"
+    "url": "https://github.com/trigora-dev/trigora-typescript"
   },
   "homepage": "https://trigora.dev/",
   "bugs": {
-    "url": "https://github.com/trigora-dev/trigora/issues"
+    "url": "https://github.com/trigora-dev/trigora-typescript/issues"
   },
   "keywords": [
-    "automation",
-    "workflow",
-    "event-driven",
-    "developer-tools",
+    "durable-execution",
     "typescript",
-    "cli",
-    "triggers",
-    "cron",
-    "queues",
-    "webhooks"
+    "workflows",
+    "agents",
+    "developer-tools"
   ],
   "license": "MIT",
   "type": "module",
@@ -37,6 +33,10 @@
     "./stripe": {
       "types": "./dist/stripe.d.ts",
       "default": "./dist/stripe.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "default": "./dist/runtime.js"
     }
   },
   "files": [
@@ -45,12 +45,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@trigora/contracts": "^0.9.0"
-  },
-  "devDependencies": {
-    "tsup": "^8.5.1"
-  },
   "scripts": {
     "build": "pnpm run build:js && pnpm run build:types",
     "build:js": "tsup",
@@ -59,5 +53,11 @@
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@trigora/contracts": "1.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Trigora
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/defineFlow.d.ts

@@ -1,53 +0,0 @@
-import type { CronEventPayload, CronFlowDefinition, FlowDefinition, FlowRunFn, JsonValue, ManualFlowDefinition, ManualTrigger, QueueFlowDefinition, QueueTrigger, RetryPolicy, Trigger, WebhookTrigger, WebhookFlowDefinition, CronTrigger } from '@trigora/contracts';
-type DefineFlowInput<TPayload, TEnv extends Record<string, string>, TTrigger extends Trigger> = {
-    id: string;
-    trigger: TTrigger;
-    /**
-     * Optional retry policy. Omitted means a single attempt.
-     * `attempts > 1` is supported for queue flows only (enforced at deploy time).
-     */
-    retry?: RetryPolicy;
-    run: TTrigger extends ManualTrigger ? FlowRunFn<TPayload, TEnv, ManualTrigger> : TTrigger extends WebhookTrigger ? FlowRunFn<TPayload, TEnv, WebhookTrigger> : TTrigger extends CronTrigger ? FlowRunFn<CronEventPayload, TEnv, CronTrigger> : TTrigger extends QueueTrigger ? FlowRunFn<TPayload, TEnv, QueueTrigger> : never;
-};
-type DefineFlowOutput<TPayload, TEnv extends Record<string, string>, TTrigger extends Trigger> = TTrigger extends ManualTrigger ? ManualFlowDefinition<TPayload, TEnv> : TTrigger extends WebhookTrigger ? WebhookFlowDefinition<TPayload, TEnv> : TTrigger extends CronTrigger ? CronFlowDefinition<TEnv> : TTrigger extends QueueTrigger ? QueueFlowDefinition<TPayload, TEnv> : FlowDefinition<TPayload, TEnv, TTrigger>;
-/**
- * Define a Trigora flow.
- *
- * Flows are plain TypeScript modules with three core parts:
- * - `id`: the internal identifier for the flow in your project
- * - `trigger`: how the flow is invoked
- * - `run`: the function that executes when the flow is triggered
- * - `retry`: optional retry policy (queue flows may use `attempts > 1`)
- *
- * `run` receives the incoming `event` and a `ctx` object with logging and environment access.
- *
- * For webhook flows, `trigger.route` controls the public hosted path and defaults to `/${id}`.
- * This is separate from the flow `id`, which is still what the CLI uses for commands like
- * `trigora deploy hello` or `trigora flows inspect hello`.
- *
- * Webhook flows can return HTTP-friendly values:
- * - `Response`
- * - plain objects / arrays / numbers / booleans
- * - `string`
- * - `null` or `undefined`
- *
- * Other trigger types generally do not need to return anything meaningful.
- *
- * @example
- * ```ts
- * export default defineFlow({
- *   id: 'stripe-webhook',
- *   trigger: { type: 'webhook', route: '/hooks/stripe' },
- *   async run(event, ctx) {
- *     await ctx.log.info('Received event', event.payload);
- *     return { ok: true };
- *   },
- * });
- * ```
- */
-export declare function defineFlow<TTrigger extends Trigger, TPayload = JsonValue, TEnv extends Record<string, string> = Record<string, string>>(flow: DefineFlowInput<TPayload, TEnv, TTrigger>): DefineFlowOutput<TPayload, TEnv, TTrigger>;
-export declare function defineFlow<TPayload = JsonValue, TEnv extends Record<string, string> = Record<string, string>>(flow: ManualFlowDefinition<TPayload, TEnv>): ManualFlowDefinition<TPayload, TEnv>;
-export declare function defineFlow<TPayload = JsonValue, TEnv extends Record<string, string> = Record<string, string>>(flow: WebhookFlowDefinition<TPayload, TEnv>): WebhookFlowDefinition<TPayload, TEnv>;
-export declare function defineFlow<TEnv extends Record<string, string> = Record<string, string>>(flow: CronFlowDefinition<TEnv>): CronFlowDefinition<TEnv>;
-export declare function defineFlow<TPayload = JsonValue, TEnv extends Record<string, string> = Record<string, string>>(flow: QueueFlowDefinition<TPayload, TEnv>): QueueFlowDefinition<TPayload, TEnv>;
-export {};