@elqnt/workflow 2.1.4 → 2.2.0

package/README.md

@@ -2,6 +2,12 @@
 
 Workflow definitions and execution for Eloquent platform. Provides models, API functions, and React hooks for building and managing workflows.
 
+> **📖 Building a custom frontend on the workflow backend?** Read
+> [`SKILL.md`](./SKILL.md) — the authoritative, per-method contract for the
+> `useWorkflows` / `useWorkflowInstances` / `useWorkflowTemplates` hooks, the
+> gateway-token flow, and the recommended app structure. The package's published
+> `.d.ts` is the source of truth; `SKILL.md` is its human-readable mirror.
+
 ## Installation
 
 ```bash

package/SKILL.md

@@ -0,0 +1,442 @@
+---
+name: workflow
+description: Build a custom frontend on the Eloquent workflow backend using the @elqnt/workflow hooks. Covers the one true path (custom app → @elqnt/workflow hooks → API Gateway → workflow Go service), the gateway-token/secret flow, and the EXACT input/output spec of every hook method (useWorkflows, useWorkflowInstances, useWorkflowTemplates — definition CRUD, instance lifecycle, node execute/resume/retry, templates) plus all types.
+---
+
+# Workflow — Building a Custom Frontend
+
+Eloquent's **workflow** service runs custom, multi-step processes: a
+**definition** is a graph of typed nodes (trigger, human action, agent, action,
+logic, loop, …); an **instance** is one live run of a definition; a **template**
+is a parameterized definition you instantiate with variables. This skill is
+**only** about one thing: building a custom app that drives it through the
+`@elqnt/workflow` package.
+
+> The package is `@elqnt/workflow`. It exports three hooks —
+> `useWorkflows` (definition CRUD), `useWorkflowInstances` (instance lifecycle +
+> node execution), and `useWorkflowTemplates` (template list/get/instantiate).
+> It also ships the Redux store slices, the JSON schemas, the typed models, the
+> browser API fns, and the `schema-builder` / `dynamic-schema-form` React
+> components.
+
+---
+
+## ⛔ The contract — read this before writing any code
+
+This skill ships **inside the package**, so the contract is not a separate file
+to keep in sync — it **is** the package's own published type declarations
+(`@elqnt/workflow` → `dist/**/*.d.ts`). Because your app *imports the real
+hooks*, the TypeScript compiler enforces the contract for you: a wrong param or a
+misused return value won't compile.
+
+The single source of truth, in order:
+
+1. `import { useWorkflows, useWorkflowInstances, useWorkflowTemplates } from "@elqnt/workflow/hooks"`
+   — the only three hooks.
+2. `import type { UseWorkflowsReturn, UseWorkflowInstancesReturn, UseWorkflowTemplatesReturn } from "@elqnt/workflow/hooks"`
+   — the **named, exact** method surface of each hook (every method, its params,
+   its return type). The tables below are a human-readable mirror of these.
+3. `import type { … } from "@elqnt/workflow/models"` — `WorkflowDefinition`,
+   `WorkflowInstance`, node/edge types, etc. (the DTOs).
+4. `import type { WorkflowTemplate } from "@elqnt/workflow/api"` — the template
+   DTO (it lives in the api ring, not models).
+
+**Rules (do not drift):**
+
+1. **Use only the three exported hooks** and only the methods they expose. Do
+   **not** invent hooks, methods, params, or return shapes — if it's not on
+   `UseWorkflowsReturn` / `UseWorkflowInstancesReturn` / `UseWorkflowTemplatesReturn`,
+   it doesn't exist.
+2. **Let the compiler check you.** Build with `tsc`; never `as any` /
+   `@ts-ignore` your way around a hook's types to force a call that isn't there.
+3. **Never bypass the hooks.** No `fetch`/`axios` to `/api/v1/workflows/...`, no
+   NATS, no direct service calls. (Server-side only: `@elqnt/workflow/api` fns +
+   `createServerClient`, same signatures.)
+4. **Wrap, don't scatter.** The hook is imported in exactly one app file
+   (`hooks/use-<domain>.ts`); see ["The domain layer"](#the-domain-layer).
+5. If a requirement seems to need a call the package doesn't define, **stop and
+   flag it** — do not improvise an endpoint.
+
+The prose/tables below explain each method; the package's shipped `.d.ts` is what
+your code type-checks against.
+
+---
+
+## Architecture — the one and only path
+
+A component **never** calls a package hook directly. It only sees your **domain
+type**, served by a **context**, backed by your **app hook**, which is the *only*
+place that wraps the `@elqnt/workflow` hook. Everything below the app hook is
+plumbing the component never imports.
+
+```
+┌──────────────────────────────────────────────────────────────────────────────┐
+│  YOUR CUSTOM APP (Next.js / React)                                             │
+│                                                                                │
+│  SSR layout: read API_GATEWAY_URL_PUBLIC (request-time) + ORG_ID               │
+│       └─► AppConfigProvider { apiGatewayUrl, orgId }                           │
+│                                                                                │
+│  components/workflows/*   ── speak only your domain type                       │
+│         │  useWorkflowsContext()                                               │
+│         ▼                                                                       │
+│  contexts/workflows-context.tsx   ── one shared app-hook instance              │
+│         │                                                                       │
+│         ▼                                                                       │
+│  hooks/use-app-workflows.ts   ── app hook: CRUD + state, the only @elqnt import│
+│         │                                                                       │
+│         ▼                                                                       │
+│  useWorkflows / useWorkflowInstances / useWorkflowTemplates  (@elqnt/workflow/hooks)│
+│         │                                                                       │
+│         ▼                                                                       │
+│  @elqnt/workflow/api  →  browserApiRequest                                    │
+│         │  getGatewayToken() ⇒ GET /api/gateway-token (mint HS256 JWT, JWT_SECRET)│
+│         │  attaches: Authorization: Bearer <jwt>, X-Org-ID, X-User-ID, X-Product│
+└─────────┼──────────────────────────────────────────────────────────────────────┘
+          ▼
+   ┌─────────────────┐   verify JWT, stamp X-Org-ID/X-Product, route match
+   │   API GATEWAY   │   /api/v1/workflows/** → workflow svc
+   └───────┬─────────┘
+           ▼
+   ┌─────────────────┐   workflow definitions / instances; node execution engine
+   │ workflow (Go)   │   per-org tenancy; emits SSE/NATS events for live nodes
+   └─────────────────┘
+```
+
+Rules: the frontend **never** calls the workflow service directly and **never**
+touches NATS. Every call is HTTP through the gateway carrying an org id + gateway
+token. And **components never import `@elqnt/workflow`** — only the app hook does.
+
+---
+
+## The gateway token (the secret) — how the custom app gets it
+
+Every request to the gateway needs `Authorization: Bearer <token>`. The token is
+a short-lived **HS256 JWT** signed with the shared **gateway secret**. You never
+hardcode it; there are two flows depending on where the code runs.
+
+### Browser flow (what the hooks use)
+
+The hooks → API fns → `browserApiRequest` → `getGatewayToken()` internally. You
+do **not** pass a token to the hook. `getGatewayToken()` (from
+`@elqnt/api-client/browser`) by default does:
+
+```
+fetch("/api/gateway-token")   ⇒  { token, expiresIn }
+```
+
+So your custom app must expose a **`/api/gateway-token` route** that mints the JWT
+server-side (the secret stays on the server, never reaches the browser). The
+client caches the token and refreshes ~5 min before expiry.
+
+```ts
+// app/api/gateway-token/route.ts  (Next.js route handler — server only)
+import { NextResponse } from "next/server";
+import * as jose from "jose";
+
+export async function GET() {
+  const secret = new TextEncoder().encode(process.env.JWT_SECRET!);  // SAME secret the gateway validates with
+  const token = await new jose.SignJWT({
+    org_id:  process.env.ORG_ID!,
+    user_id: "system",
+    email:   "system@my-app.com",
+    role:    "system",
+    scopes:  ["read:workflows", "write:workflows"],   // OR-matched against the route's required scopes
+    product: "my-product",                            // gateway resolves product from THIS claim first
+  })
+    .setProtectedHeader({ alg: "HS256" })
+    .setIssuedAt()
+    .setIssuer("eloquent-gateway")     // must match gateway JWT_ISSUER
+    .setAudience("eloquent-api")       // must match gateway JWT_AUDIENCE
+    .setExpirationTime("1h")
+    .sign(secret);
+
+  return NextResponse.json({ token, expiresIn: 3600 });
+}
+```
+
+> The gateway re-stamps `X-Org-ID` / `X-User-ID` / `X-Product` from the **signed
+> JWT claims** before proxying, so a forged header can't override the token — the
+> JWT is authoritative. Routes declare required `scopes` (read routes need none;
+> create/update/delete need `write:workflows`); the check is an **OR** match, and
+> `admin`/`super_admin` role or a `*` scope bypasses it.
+
+Override the token source (mobile/native, or a non-default URL) once at startup:
+
+```ts
+import { configureAuth } from "@elqnt/api-client/browser";
+configureAuth(async () => myTokenProvider());     // URL string or async () => token|null
+// clearGatewayTokenCache()  — call after switching orgs
+```
+
+### Server flow (server actions / SSR)
+
+`@elqnt/api-client/server` mints the JWT itself with `jose` — no
+`/api/gateway-token` hop. This is where the secret is injected directly:
+
+```ts
+import { createServerClient } from "@elqnt/api-client/server";
+
+const client = createServerClient({
+  gatewayUrl: process.env.API_GATEWAY_URL_INTERNAL!,  // in-cluster gateway URL (server-side)
+  jwtSecret:  process.env.JWT_SECRET!,                // the shared gateway secret
+  defaultProduct: "my-product",                        // REQUIRED: gateway reads product from the JWT claim first
+  defaultScopes: ["read", "write", "admin"],
+});
+
+await client.get("/api/v1/workflows", { orgId, userId });
+```
+
+> The workflow **hooks are browser-only** (`"use client"`). For SSR/server
+> actions call the API fns or `createServerClient` directly — not the hooks.
+
+### Env vars
+
+| Var | Used by | Purpose |
+|---|---|---|
+| `JWT_SECRET` | `/api/gateway-token` route + `createServerClient` | sign the gateway JWT (same value the gateway validates with) |
+| `API_GATEWAY_URL_INTERNAL` | `createServerClient` `gatewayUrl` | in-cluster gateway URL (server) |
+| `API_GATEWAY_URL_PUBLIC` | SSR layout → `AppConfigProvider` → browser `baseUrl` | public gateway URL, read **at request time** (not `NEXT_PUBLIC_*`) |
+| `ORG_ID` | token route / app config | the org all requests are scoped to |
+
+### Headers the API layer sets per request
+
+| From hook option | Header |
+|---|---|
+| auto token | `Authorization: Bearer <token>` |
+| `orgId` | `X-Org-ID` |
+| `userId` | `X-User-ID` |
+| `userEmail` | `X-User-Email` |
+| `product` (default `"eloquent"`) | `X-Product` |
+
+---
+
+## Hook options (all three hooks)
+
+There is **no provider/context**. You pass options into each hook call. All three
+take `ApiClientOptions`:
+
+```ts
+interface ApiClientOptions {
+  baseUrl: string;     // API Gateway base URL — required
+  orgId: string;       // required → X-Org-ID
+  userId?: string;     // → X-User-ID
+  userEmail?: string;  // → X-User-Email
+  product?: string;    // → X-Product, defaults to "eloquent"
+  headers?: Record<string, string>;
+}
+
+type UseWorkflowsOptions          = ApiClientOptions;
+type UseWorkflowInstancesOptions  = ApiClientOptions;
+type UseWorkflowTemplatesOptions  = ApiClientOptions;
+```
+
+> **Imperative, not auto-fetching.** Every method is an `async` function you call
+> on demand; there is **no** `useEffect`-on-mount inside the hook. Each hook
+> exposes aggregate `loading` and `error` flags. On failure a method returns its
+> default (`[]`, `null`, `false`) and sets `error` — it does **not** throw.
+
+---
+
+## Hook: `useWorkflows` (definition CRUD)
+
+```ts
+import { useWorkflows } from "@elqnt/workflow/hooks";
+
+const wf = useWorkflows({ baseUrl, orgId, product: "my-product" });
+```
+
+Returns `{ loading, error, ...methods }`:
+
+| Method | Signature | Resolves to | Endpoint |
+|---|---|---|---|
+| `listWorkflows` | `() => Promise<WorkflowDefinition[]>` | `[]` on error | `GET /api/v1/workflows` |
+| `getWorkflow` | `(workflowId: string) => Promise<WorkflowDefinition \| null>` | `null` | `GET /api/v1/workflows/{id}` |
+| `createWorkflow` | `(workflow: Partial<WorkflowDefinition>) => Promise<WorkflowDefinition \| null>` | created definition | `POST /api/v1/workflows` |
+| `updateWorkflow` | `(workflowId: string, workflow: Partial<WorkflowDefinition>) => Promise<WorkflowDefinition \| null>` | updated definition | `PUT /api/v1/workflows/{id}` |
+| `deleteWorkflow` | `(workflowId: string) => Promise<boolean>` | `true`/`false` | `DELETE /api/v1/workflows/{id}` |
+
+---
+
+## Hook: `useWorkflowInstances` (instance lifecycle + node execution)
+
+```ts
+import { useWorkflowInstances } from "@elqnt/workflow/hooks";
+
+const inst = useWorkflowInstances({ baseUrl, orgId, product: "my-product" });
+```
+
+Returns `{ loading, error, ...methods }`:
+
+| Method | Signature | Resolves to | Endpoint |
+|---|---|---|---|
+| `listInstances` | `(definitionId: string, filters?: { userId?: string; status?: string }) => Promise<WorkflowInstance[]>` | `[]` | `GET /api/v1/workflows/{definitionId}/instances` (`?userId=&status=`) |
+| `getInstance` | `(instanceId: string) => Promise<WorkflowInstance \| null>` | `null` | `GET /api/v1/workflows/instances/{id}` |
+| `createInstance` | `(definitionId: string, data?: { variables?: Record<string, unknown>; autoExecute?: boolean }) => Promise<WorkflowInstance \| null>` | new instance | `POST /api/v1/workflows/{definitionId}/instances` |
+| `updateStatus` | `(instanceId: string, status: string) => Promise<WorkflowInstance \| null>` | updated instance | `PUT /api/v1/workflows/instances/{id}/status` body `{ status }` |
+| `executeNode` | `(instanceId: string, nodeId: string, input: Record<string, unknown>) => Promise<Record<string, unknown> \| null>` | node output map | `POST .../instances/{id}/nodes/{nodeId}/execute` body `{ input }` |
+| `resumeNode` | `(instanceId: string, nodeId: string, result: Record<string, unknown>) => Promise<WorkflowInstance \| null>` | updated instance | `POST .../instances/{id}/nodes/{nodeId}/resume` body `{ result }` |
+| `retryNode` | `(instanceId: string, nodeId: string) => Promise<WorkflowInstance \| null>` | updated instance | `POST .../instances/{id}/nodes/{nodeId}/retry` |
+
+> `resumeNode` is the **human-in-the-loop** completion call: a paused
+> `humanAction` node (review / approval / data-entry / assignment) resumes when
+> you POST the human's `result`. `retryNode` re-runs a failed node.
+
+---
+
+## Hook: `useWorkflowTemplates` (template list / get / instantiate)
+
+```ts
+import { useWorkflowTemplates } from "@elqnt/workflow/hooks";
+
+const tpl = useWorkflowTemplates({ baseUrl, orgId, product: "my-product" });
+```
+
+Returns `{ loading, error, ...methods }`:
+
+| Method | Signature | Resolves to | Endpoint |
+|---|---|---|---|
+| `listTemplates` | `(category?: string) => Promise<WorkflowTemplate[]>` | `[]` | `GET /api/v1/workflows/templates` (`?category=`) |
+| `getTemplate` | `(templateId: string) => Promise<WorkflowTemplate \| null>` | `null` | `GET /api/v1/workflows/templates/{id}` |
+| `instantiateTemplate` | `(templateId: string, params: { variables: Record<string, unknown>; title?: string }) => Promise<WorkflowDefinition \| null>` | new definition | `POST /api/v1/workflows/templates/{id}/instantiate` |
+
+```ts
+interface WorkflowTemplate {
+  id: string;
+  name: string;
+  title: string;
+  description: string;
+  category: string;
+  variables: Array<{ name: string; type: string; required: boolean; description?: string }>;
+  preview?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+```
+
+---
+
+## Core models (`@elqnt/workflow/models`)
+
+The definition/instance DTOs are tygo-generated from the Go service. The shapes
+below are the load-bearing fields; the package's `.d.ts` is the full, authoritative
+list.
+
+```ts
+interface WorkflowDefinition {
+  id: string;
+  title: string;
+  description: string;
+  nodes: WorkflowNode[];      // the graph
+  edges: WorkflowEdge[];      // connections between nodes
+  variables?: Record<string, unknown>;
+  status: string;            // draft | active | …
+  version: number;
+  createdAt: string;
+  updatedAt: string;
+  // …plus trigger/metadata fields — see models/workflow.ts
+}
+
+interface WorkflowInstance {
+  id: string;
+  definitionId: string;
+  status: string;            // running | paused | completed | failed | …
+  currentNodeIds: string[];  // nodes currently active / awaiting input
+  variables: Record<string, unknown>;
+  nodeStates: Record<string, unknown>;  // per-node execution state
+  createdAt: string;
+  updatedAt: string;
+}
+```
+
+**Node types** (`NodeType` consts): `trigger`, `humanAction`, `agent`, `action`,
+`logic`, `loop`, `parallel`, `delay`, `data`, `integration`, `timer`, `subflow`,
+`custom`, `accounting`, `documentExtraction`. Each has a `NodeSubType` family
+(e.g. `humanActionApproval`, `agentChat`, `actionSendEmail`,
+`logicIf`/`logicSwitch`/`logicFor`). The full enumerations live in
+`models/workflow.ts` — reference them by the exported consts, never string
+literals.
+
+---
+
+## Store, schema & components (other rings)
+
+- **Redux store** (`@elqnt/workflow`, root): `workflowDefinitionReducer` and
+  `workflowInstanceReducer` (+ their `*State` / `*Selector` types). Mount them in
+  your `configureStore`. These are how the editor UI holds in-progress
+  definition/instance state client-side.
+- **JSON schemas** (`@elqnt/workflow`, root, via `./schema`): generated JSON
+  Schemas for node config validation.
+- **Components** (`@elqnt/workflow/components`, also re-exported from root):
+  `SchemaBuilder` and `DynamicSchemaForm` — `"use client"` React building blocks
+  for editing node config schemas and rendering schema-driven forms.
+
+---
+
+## The domain layer
+
+A real custom app stacks **models → app hook → context → components** on top of
+the package hooks, so components never see `WorkflowDefinition`/`WorkflowInstance`
+or the gateway directly.
+
+| Layer | Where (your app) | Role |
+|---|---|---|
+| Components | `components/<domain>/*` | render; consume the context; see only the domain type |
+| Context | `contexts/<domain>-context.tsx` | one shared app-hook instance for the subtree |
+| App hook | `hooks/use-app-workflows.ts` | CRUD + state; **the only file importing `@elqnt/workflow`** |
+| Domain type | `models/<domain>.ts` | the camelCase business type |
+| Config | `contexts/app-config-context.tsx` | `{ apiGatewayUrl, orgId }` from SSR |
+| — package — | `@elqnt/workflow/{hooks,api,models}` | the gateway client the app hook wraps |
+
+```ts
+// hooks/use-app-workflows.ts — the ONLY file that imports @elqnt/workflow
+"use client";
+import { useMemo } from "react";
+import { useWorkflows, useWorkflowInstances } from "@elqnt/workflow/hooks";
+import { useAppConfig } from "@/contexts/app-config-context";
+
+export function useAppWorkflows() {
+  const { apiGatewayUrl, orgId } = useAppConfig();
+  const defs = useWorkflows({ baseUrl: apiGatewayUrl, orgId, product: "my-product" });
+  const inst = useWorkflowInstances({ baseUrl: apiGatewayUrl, orgId, product: "my-product" });
+
+  return useMemo(() => ({
+    loading: defs.loading || inst.loading,
+    error: defs.error ?? inst.error,
+    listWorkflows: defs.listWorkflows,
+    startRun: (definitionId: string) => inst.createInstance(definitionId, { autoExecute: true }),
+    approve: (instanceId: string, nodeId: string, result: Record<string, unknown>) =>
+      inst.resumeNode(instanceId, nodeId, result),
+  }), [defs, inst]);
+}
+
+export type UseAppWorkflowsReturn = ReturnType<typeof useAppWorkflows>;
+```
+
+Read the gateway URL **server-side at request time from
+`API_GATEWAY_URL_PUBLIC`** and forward it through `AppConfigProvider` — do **not**
+use a `NEXT_PUBLIC_*` var (those bake the build-env URL into the bundle forever).
+
+---
+
+## Gotchas
+
+- **Three hooks, reached only via `@elqnt/workflow/hooks`.** The root barrel
+  re-exports models / api / store / schema / components — **never** the hooks
+  (rule 1, the root-barrel rule). Import hooks from the `/hooks` subpath so
+  `"use client"` is never dragged into a server-component import.
+- **Methods don't throw.** They return defaults (`[]` / `null` / `false`) and set
+  `error`. Check `error` / null results; don't wrap in try/catch expecting throws.
+- **The package has no provider.** Options go into every hook call — which is why
+  your app builds `AppConfigProvider` (inject `baseUrl`/`orgId` once via SSR) and
+  the domain context, so components and the app hook never re-thread config.
+- **Components never import `@elqnt/workflow`.** It's wrapped in one app hook;
+  components speak the domain type via the context.
+- **`product` matters.** The gateway resolves product from the **JWT claim**
+  first (server) and `X-Product` (browser). Mismatched product = wrong tenancy.
+- **`WorkflowTemplate` lives in `@elqnt/workflow/api`, not `/models`.** The
+  template DTO + its responses are defined alongside the API fns.
+- **Human-in-the-loop = `resumeNode`.** A paused `humanAction` node resumes only
+  when you POST the human's `result` via `resumeNode`; `retryNode` re-runs a
+  failed node. Use the node's `id` from the instance's `currentNodeIds`.
+- **Hooks are browser-only.** For SSR / server actions call the `@elqnt/workflow/api`
+  fns (or `createServerClient`) directly — same signatures, no React.

package/dist/api/index.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
 
@@ -14,8 +14,8 @@
 
 
 
+var _chunkYCO5IFZKjs = require('../chunk-YCO5IFZK.js');
 
-var _chunkJES2EBNOjs = require('../chunk-JES2EBNO.js');
 
 
 
@@ -31,6 +31,5 @@ var _chunkJES2EBNOjs = require('../chunk-JES2EBNO.js');
 
 
 
-
-exports.createWorkflowApi = _chunkJES2EBNOjs.createWorkflowApi; exports.createWorkflowInstanceApi = _chunkJES2EBNOjs.createWorkflowInstanceApi; exports.deleteWorkflowApi = _chunkJES2EBNOjs.deleteWorkflowApi; exports.executeWorkflowNodeApi = _chunkJES2EBNOjs.executeWorkflowNodeApi; exports.getWorkflowApi = _chunkJES2EBNOjs.getWorkflowApi; exports.getWorkflowInstanceApi = _chunkJES2EBNOjs.getWorkflowInstanceApi; exports.getWorkflowTemplateApi = _chunkJES2EBNOjs.getWorkflowTemplateApi; exports.instantiateWorkflowTemplateApi = _chunkJES2EBNOjs.instantiateWorkflowTemplateApi; exports.listWorkflowInstancesApi = _chunkJES2EBNOjs.listWorkflowInstancesApi; exports.listWorkflowTemplatesApi = _chunkJES2EBNOjs.listWorkflowTemplatesApi; exports.listWorkflowsApi = _chunkJES2EBNOjs.listWorkflowsApi; exports.resumeWorkflowNodeApi = _chunkJES2EBNOjs.resumeWorkflowNodeApi; exports.retryWorkflowNodeApi = _chunkJES2EBNOjs.retryWorkflowNodeApi; exports.updateWorkflowApi = _chunkJES2EBNOjs.updateWorkflowApi; exports.updateWorkflowInstanceStatusApi = _chunkJES2EBNOjs.updateWorkflowInstanceStatusApi;
+exports.createWorkflowApi = _chunkYCO5IFZKjs.createWorkflowApi; exports.createWorkflowInstanceApi = _chunkYCO5IFZKjs.createWorkflowInstanceApi; exports.deleteWorkflowApi = _chunkYCO5IFZKjs.deleteWorkflowApi; exports.executeWorkflowNodeApi = _chunkYCO5IFZKjs.executeWorkflowNodeApi; exports.getWorkflowApi = _chunkYCO5IFZKjs.getWorkflowApi; exports.getWorkflowInstanceApi = _chunkYCO5IFZKjs.getWorkflowInstanceApi; exports.getWorkflowTemplateApi = _chunkYCO5IFZKjs.getWorkflowTemplateApi; exports.instantiateWorkflowTemplateApi = _chunkYCO5IFZKjs.instantiateWorkflowTemplateApi; exports.listWorkflowInstancesApi = _chunkYCO5IFZKjs.listWorkflowInstancesApi; exports.listWorkflowTemplatesApi = _chunkYCO5IFZKjs.listWorkflowTemplatesApi; exports.listWorkflowsApi = _chunkYCO5IFZKjs.listWorkflowsApi; exports.resumeWorkflowNodeApi = _chunkYCO5IFZKjs.resumeWorkflowNodeApi; exports.retryWorkflowNodeApi = _chunkYCO5IFZKjs.retryWorkflowNodeApi; exports.updateWorkflowApi = _chunkYCO5IFZKjs.updateWorkflowApi; exports.updateWorkflowInstanceStatusApi = _chunkYCO5IFZKjs.updateWorkflowInstanceStatusApi;
 //# sourceMappingURL=index.js.map

package/dist/api/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/eloquent/eloquent/packages/@elqnt/workflow/dist/api/index.js"],"names":[],"mappings":"AAAA,qFAAY;AACZ;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,uDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,qkCAAC","file":"/home/runner/work/eloquent/eloquent/packages/@elqnt/workflow/dist/api/index.js"}
+{"version":3,"sources":["/home/runner/work/eloquent/eloquent/packages/@elqnt/workflow/dist/api/index.js"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,uDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,qkCAAC","file":"/home/runner/work/eloquent/eloquent/packages/@elqnt/workflow/dist/api/index.js"}

package/dist/api/index.mjs

@@ -1,4 +1,3 @@
-"use client";
 import {
   createWorkflowApi,
   createWorkflowInstanceApi,
@@ -15,7 +14,7 @@ import {
   retryWorkflowNodeApi,
   updateWorkflowApi,
   updateWorkflowInstanceStatusApi
-} from "../chunk-UE4ZBFLG.mjs";
+} from "../chunk-4AUWFGQK.mjs";
 export {
   createWorkflowApi,
   createWorkflowInstanceApi,