@voyant-travel/hono 0.133.0 → 0.134.1

package/dist/app.d.ts

@@ -34,9 +34,8 @@ export interface ModuleMount {
 /**
  * App handle returned alongside the Hono instance. Carries `ready()` for
  * headless / sibling-process deployments that need to fire the lazy
- * bootstrap before the first HTTP request — workflow runtimes (node
- * sibling-process pattern, tests) call this so the time wheel and
- * manifest registration kick off without traffic.
+ * bootstrap before the first HTTP request. Resident hosts and tests call this
+ * so selected runtime registration completes without waiting for traffic.
  *
  * Returned via the augmented Hono instance: `app.ready` is attached
  * directly so the existing call sites (which destructure / pass `app`

package/dist/app.js

@@ -1,10 +1,9 @@
 // agent-quality: file-size exception — app.ts is the framework composition root;
 // splitting it is intentional follow-up work, not part of voyant#2114.
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { createContainer, createEventBus, createQueryRunner, } from "@voyant-travel/core";
+import { createContainer, createEventBus, createQueryRunner } from "@voyant-travel/core";
 import { createLinkServiceFactory } from "@voyant-travel/db/links";
 import { assembleAnonymousPaths, assembleOptionalCustomerAuthPaths } from "./anonymous-paths.js";
-import { containerToServiceResolver, makeFrameworkLogger, wireWorkflowRuntime, } from "./app-workflows.js";
 import { composeAuthAugmentations } from "./auth-augmentation.js";
 import { expandApiBundles, isLazyApiBundle, } from "./bundle.js";
 import { assembleClientAuthenticatedRoutes, matchesClientAuthenticatedRoute, } from "./client-authenticated-routes.js";
@@ -137,48 +136,6 @@ export function mountApp(config) {
     for (const sub of expanded?.subscribers ?? []) {
         eventBus.subscribe(sub.event, sub.handler, { inline: sub.inline ?? false });
     }
-    // ---- Workflow runtime wiring (synchronous setup; manifest registration
-    //      + EventBus forwarder run inside the lazy bootstrap below) ----
-    //
-    // We collect `workflows` + `eventFilters` from every module and plugin
-    // here so the failure mode for "duplicate workflow id across modules"
-    // surfaces at construction time (per architecture doc §18, the workflow
-    // runtime is fail-closed).
-    const collectedWorkflows = [];
-    const collectedFilters = [];
-    function collectModuleRuntimeDescriptors(modules) {
-        for (const mod of modules) {
-            if (mod.module.workflows)
-                collectedWorkflows.push(...mod.module.workflows);
-            if (mod.module.eventFilters)
-                collectedFilters.push(...mod.module.eventFilters);
-        }
-    }
-    function collectPluginRuntimeDescriptors(plugins) {
-        for (const plugin of plugins) {
-            if (plugin.workflows)
-                collectedWorkflows.push(...plugin.workflows);
-            if (plugin.eventFilters)
-                collectedFilters.push(...plugin.eventFilters);
-        }
-    }
-    function assertUniqueWorkflowIds() {
-        if (!config.workflows || collectedWorkflows.length === 0)
-            return;
-        const seen = new Map();
-        for (const wf of collectedWorkflows) {
-            const existing = seen.get(wf.id);
-            if (existing && existing !== wf) {
-                throw new Error(`[voyant] duplicate workflow id "${wf.id}" registered by multiple modules/plugins. ` +
-                    `Workflow ids must be unique across the app — use a module-scoped prefix ` +
-                    `(e.g. "${wf.id.includes(".") ? wf.id : `<module>.${wf.id}`}").`);
-            }
-            seen.set(wf.id, wf);
-        }
-    }
-    collectModuleRuntimeDescriptors(allModules);
-    collectPluginRuntimeDescriptors(eagerPlugins);
-    assertUniqueWorkflowIds();
     const txModuleNames = new Set();
     const txRequiringModules = [];
     const txPrefixes = [...(config.dbTransactionalPaths ?? [])];
@@ -273,8 +230,6 @@ export function mountApp(config) {
         for (const sub of lazyExpanded.subscribers) {
             eventBus.subscribe(sub.event, sub.handler, { inline: sub.inline ?? false });
         }
-        collectModuleRuntimeDescriptors(lazyExpanded.modules);
-        collectPluginRuntimeDescriptors(pending);
         addTransactionalSurfaces(lazyExpanded.modules, lazyExpanded.extensions);
     }
     async function ensureBootstrapLazyPluginsExpanded() {
@@ -293,47 +248,12 @@ export function mountApp(config) {
         }
         await lazyPluginExpansionPromise;
     }
-    // Workflow driver construction is **deferred** to the lazy bootstrap
-    // path so callers whose driver options come from `env.*` bindings can
-    // pass a function-of-bindings shape. Node / InMemory users usually
-    // return a direct factory from that function.
-    let workflowDriver;
     let bootstrapPromise = null;
     function ensureRuntimeBootstrapped(bindings) {
         if (!bootstrapPromise) {
             bootstrapPromise = (async () => {
                 const ctx = { bindings, container, eventBus };
                 await ensureBootstrapLazyPluginsExpanded();
-                assertUniqueWorkflowIds();
-                // ---- Workflow runtime FIRST — fail-closed manifest registration
-                //      and EventBus forwarder must be in place before any module
-                //      bootstrap can emit. Otherwise a `module.bootstrap` that
-                //      emits an event during its own bootstrap would route through
-                //      a bus with no workflow forwarder yet, silently losing the
-                //      event. Per architecture doc §21.22 + reviewer feedback P2.3.
-                if (config.workflows) {
-                    // `driver` is always a function-of-bindings (per
-                    // VoyantWorkflowsConfig — see types.ts + reviewer feedback P2.1).
-                    // Node / InMemory users wrap with `() => createXxxDriver({...})`.
-                    // Managed-cloud users can derive a forwarding driver from `env`.
-                    // We invoke with bindings, then the resulting DriverFactory
-                    // with framework deps.
-                    const factoryDeps = {
-                        services: containerToServiceResolver(container),
-                        logger: makeFrameworkLogger(config.logger),
-                    };
-                    const factory = config.workflows.driver(bindings);
-                    workflowDriver = factory(factoryDeps);
-                    await wireWorkflowRuntime({
-                        modules: allModules.map((m) => m.module),
-                        collectedWorkflows,
-                        collectedFilters,
-                        driver: workflowDriver,
-                        environment: config.workflows.environment ?? "development",
-                        projectId: config.workflows.projectId ?? "default",
-                        eventBus,
-                    });
-                }
                 // Run each bootstrap in isolation — a single failing plugin/module/extension
                 // must not poison the cached promise and kill the whole app's request pipeline.
                 const runIsolated = async (label, fn) => {
@@ -521,10 +441,8 @@ export function mountApp(config) {
     app.use("*", db(dbSource, { requiresTransactionalDb: txRequiringModules, basePath: config.basePath }));
     app.use("*", async (c, next) => {
         // Bootstrap only after auth has admitted the request. Rejected requests
-        // must not initialize package runtimes or contact workflow infrastructure.
+        // must not initialize package runtimes.
         await ensureRuntimeBootstrapped(c.env);
-        if (workflowDriver)
-            c.set("workflowDriver", workflowDriver);
         return next();
     });
     if (createRequestLinkService) {

package/dist/bundle.d.ts

@@ -1,4 +1,4 @@
-import type { BootstrapHandler, EventFilterDescriptor, LinkDefinition, Subscriber, WorkflowDescriptor } from "@voyant-travel/core";
+import type { BootstrapHandler, LinkDefinition, Subscriber } from "@voyant-travel/core";
 import type { ApiExtension, ApiModule } from "./module.js";
 /**
  * Reusable server API contribution surface.
@@ -37,17 +37,6 @@ export interface ApiBundle {
      * these into the assembled anonymous allow-list.
      */
     anonymous?: string[];
-    /**
-     * Workflows contributed by the plugin. Mirrors the `Plugin.workflows`
-     * field in `@voyant-travel/core` — collected at `createApp()` boot and
-     * registered with the configured workflow driver.
-     */
-    workflows?: readonly WorkflowDescriptor[];
-    /**
-     * Event filters contributed by the plugin. Mirrors
-     * `Plugin.eventFilters` in `@voyant-travel/core`.
-     */
-    eventFilters?: readonly EventFilterDescriptor[];
 }
 declare const LAZY_API_BUNDLE: unique symbol;
 /**
@@ -89,8 +78,7 @@ export interface LazyApiBundle {
     /**
      * Load this bundle during app bootstrap instead of waiting for a declared
      * route matcher. Set this for lazy bundles that contribute subscribers,
-     * workflow metadata, container services, or bootstraps needed before a
-     * bundle-owned route is hit.
+     * container services, or bootstraps needed before a bundle-owned route is hit.
      */
     loadOnBootstrap?: boolean;
     /** Loads and constructs the real bundle. Memoized by `mountApp`. */

package/dist/openapi.d.ts

@@ -141,8 +141,7 @@ export declare function buildModulePathOwnership(mounts: readonly ModuleMount[],
  * admin/storefront path (voyant#2733).
  *
  * Uses the ownership map as the authoritative module owner, falling back to the
- * path's own segment for anything the manifest doesn't claim (e.g.
- * `additionalRoutes` mounts like the operator's workflow-runs admin surface).
+ * path's own segment for anything the manifest doesn't claim.
  * The full surface is therefore partitioned exactly: every `/v1/admin/*` and
  * `/v1/public/*` path lands in exactly one module document. Non-surface routes
  * (`/v1/<name>` webhooks, legacy `/v1/*`) live only in the aggregate, as before.

package/dist/openapi.js

@@ -220,8 +220,7 @@ export async function buildModulePathOwnership(mounts, options) {
  * admin/storefront path (voyant#2733).
  *
  * Uses the ownership map as the authoritative module owner, falling back to the
- * path's own segment for anything the manifest doesn't claim (e.g.
- * `additionalRoutes` mounts like the operator's workflow-runs admin surface).
+ * path's own segment for anything the manifest doesn't claim.
  * The full surface is therefore partitioned exactly: every `/v1/admin/*` and
  * `/v1/public/*` path lands in exactly one module document. Non-surface routes
  * (`/v1/<name>` webhooks, legacy `/v1/*`) live only in the aggregate, as before.

package/dist/types.d.ts

@@ -2,7 +2,6 @@ import type { Actor, VoyantVariables as CoreVoyantVariables, EventBus, LinkDefin
 import type { SelectApikey } from "@voyant-travel/db/schema/iam";
 import type { AccessCatalog } from "@voyant-travel/types/api-keys";
 import type { KVStore } from "@voyant-travel/utils/cache";
-import type { DriverFactory } from "@voyant-travel/workflows/driver";
 import type { NeonHttpDatabase } from "drizzle-orm/neon-http";
 import type { NeonDatabase as NeonWsDatabase } from "drizzle-orm/neon-serverless";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
@@ -47,8 +46,6 @@ export type VoyantVariables = CoreVoyantVariables & {
     link?: LinkService;
     /** Shared cross-module query runtime, when the app wires one in. */
     query?: VoyantQueryRuntime;
-    /** Optional workflow driver surfaced to HTTP routes after lazy app bootstrap. */
-    workflowDriver?: import("@voyant-travel/workflows/driver").WorkflowDriver;
 };
 /** Handler contract for application-authored Hono API routes. */
 export type VoyantRouteHandler<TBindings extends VoyantBindings = VoyantBindings> = Handler<{
@@ -291,17 +288,6 @@ export interface VoyantAppConfig<TBindings extends VoyantBindings = VoyantBindin
      * individual policies.
      */
     rateLimit?: false | import("./middleware/rate-limit.js").RateLimitConfig;
-    /**
-     * Workflow runtime configuration. When set, `createApp()` collects
-     * `module.workflows` + `module.eventFilters` (plus the same fields
-     * from plugins), invokes `workflows.driver` with framework deps, and
-     * — inside the lazy bootstrap path — registers the manifest with the
-     * driver and installs an EventBus forwarder that routes emitted
-     * events to `driver.ingestEvent(...)`.
-     *
-     * See `docs/architecture/workflows-runtime-architecture.md` §6, §18.
-     */
-    workflows?: VoyantWorkflowsConfig;
     /**
      * Admin API capability metadata, served at `GET /v1/admin/_meta/capabilities`
      * so clients (the admin SDK) can discover what this deployment supports —
@@ -325,58 +311,3 @@ export interface VoyantAppConfig<TBindings extends VoyantBindings = VoyantBindin
     };
     additionalRoutes?: (app: Hono<any>) => void;
 }
-/**
- * Workflow runtime configuration block. The driver is resolved at boot
- * time (inside the lazy bootstrap path), after framework deps and —
- * crucially — after runtime bindings are available.
- *
- * `driver` is **always** a function-of-bindings: `(env) => DriverFactory`.
- * This unambiguous shape works for local node runtimes and managed-cloud
- * forwarding drivers:
- *
- * **Node / InMemory** — wrap your direct factory:
- *
- *     workflows: {
- *       driver: () => createStandaloneDriver({ db }),
- *     }
- *
- * **Managed Cloud forwarding** — pull credentials off `env`:
- *
- *     workflows: {
- *       driver: (env) => () => createCloudWorkflowDriver({
- *         baseUrl: env.VOYANT_CLOUD_WORKFLOWS_URL,
- *         triggerToken: env.VOYANT_CLOUD_WORKFLOW_TRIGGER_TOKEN,
- *         appSlug: env.VOYANT_CLOUD_APP_SLUG,
- *         environment: env.VOYANT_CLOUD_ENVIRONMENT,
- *       }),
- *     }
- *
- * The single shape avoids ambiguous "is this a factory or a
- * factory-of-factories?" heuristics. See architecture doc §6.3 +
- * reviewer feedback P2.1.
- */
-export interface VoyantWorkflowsConfig<TBindings = unknown> {
-    /**
-     * Function-of-bindings that returns a `DriverFactory`. Resolved
-     * lazily with `c.env` once bindings are available, then invoked
-     * with `{ services, logger }` to produce the driver.
-     */
-    driver: (bindings: TBindings) => DriverFactory;
-    /**
-     * Environment the manifest registers under. Defaults to `"development"`.
-     * Workflow filters are environment-scoped (production manifests don't
-     * see preview events and vice versa) per architecture doc §21.10.
-     */
-    environment?: "production" | "preview" | "development";
-    /**
-     * Project / tenant identifier baked into the manifest. Single-tenant
-     * runtimes leave this unset (defaults to `"default"`). Multi-tenant
-     * deployments override per-app via voyant-cloud's wrapper layer.
-     */
-    projectId?: string;
-}
-/**
- * Structural shape of a `DriverFactory` from `@voyant-travel/workflows/driver`.
- * The SDK package's concrete `DriverFactory` satisfies this via TS
- * structural compat (architecture doc §21.19).
- */

package/dist/types.js

@@ -22,8 +22,3 @@ export function resolveDbFactoryResult(value) {
     const dispose = dbClientDispose(value);
     return dispose ? { db: value, dispose } : { db: value };
 }
-/**
- * Structural shape of a `DriverFactory` from `@voyant-travel/workflows/driver`.
- * The SDK package's concrete `DriverFactory` satisfies this via TS
- * structural compat (architecture doc §21.19).
- */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyant-travel/hono",
-  "version": "0.133.0",
+  "version": "0.134.1",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -130,17 +130,15 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.27",
     "zod": "^4.4.3",
-    "@voyant-travel/core": "^0.130.0",
-    "@voyant-travel/db": "^0.117.1",
-    "@voyant-travel/types": "^0.109.8",
+    "@voyant-travel/core": "^0.132.0",
+    "@voyant-travel/db": "^0.118.1",
     "@voyant-travel/utils": "^0.109.0",
-    "@voyant-travel/workflows": "^0.122.18"
+    "@voyant-travel/types": "^0.109.9"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
     "vitest": "^4.1.9",
-    "@voyant-travel/voyant-typescript-config": "^0.1.0",
-    "@voyant-travel/workflows-orchestrator": "^0.122.18"
+    "@voyant-travel/voyant-typescript-config": "^0.1.0"
   },
   "files": [
     "dist"

package/dist/app-workflows.d.ts

@@ -1,30 +0,0 @@
-import type { EventEnvelope, EventFilterDescriptor, Module, ModuleContainer, WorkflowDescriptor } from "@voyant-travel/core";
-import type { WorkflowDriver } from "@voyant-travel/workflows/driver";
-import type { VoyantAppConfig } from "./types.js";
-export interface WireWorkflowRuntimeArgs {
-    modules: ReadonlyArray<Module>;
-    collectedWorkflows: ReadonlyArray<WorkflowDescriptor>;
-    collectedFilters: ReadonlyArray<EventFilterDescriptor>;
-    driver: WorkflowDriver;
-    environment: "production" | "preview" | "development";
-    projectId: string;
-    eventBus: {
-        subscribe(event: string, handler: (e: EventEnvelope) => Promise<void> | void): unknown;
-    };
-}
-/**
- * Build the manifest, register it with the driver, and install a single
- * EventBus subscriber per unique eventType seen across the manifest's filters.
- */
-export declare function wireWorkflowRuntime(args: WireWorkflowRuntimeArgs): Promise<void>;
-/**
- * Adapt the framework's `ModuleContainer` to a read-only `ServiceResolver`.
- */
-export declare function containerToServiceResolver(container: ModuleContainer): {
-    resolve<T>(name: string): T;
-    has(name: string): boolean;
-};
-/**
- * Adapt the framework's optional `LoggerProvider` to the workflow driver logger.
- */
-export declare function makeFrameworkLogger(loggerProvider: VoyantAppConfig["logger"] | undefined): (level: "debug" | "info" | "warn" | "error", msg: string, data?: object) => void;

package/dist/app-workflows.js

@@ -1,115 +0,0 @@
-function toManifestWorkflowDescriptor(wf) {
-    const candidate = wf;
-    return candidate.config ? { id: wf.id, config: candidate.config } : { id: wf.id };
-}
-/**
- * Build the manifest, register it with the driver, and install a single
- * EventBus subscriber per unique eventType seen across the manifest's filters.
- */
-export async function wireWorkflowRuntime(args) {
-    // Keep app composition importable before workspace packages are built. The
-    // workflow implementation is needed only when a configured app boots.
-    const { buildManifest } = await import("@voyant-travel/workflows/events");
-    // The descriptors collected from modules + plugins use core's structural
-    // types (`{ id, eventType }` only - see `EventFilterDescriptor` in core);
-    // the manifest builder needs the runtime shape with `.manifest` populated.
-    // Validate before casting so a contract-violating plugin fails loudly here
-    // instead of crashing on `entry.manifest.id` deep inside the sort.
-    const filterEntries = [];
-    for (const entry of args.collectedFilters) {
-        const candidate = entry;
-        if (!candidate.manifest || typeof candidate.manifest.id !== "string") {
-            throw new Error(`[voyant] event filter "${entry.id}" (event "${entry.eventType}") is missing the runtime ` +
-                `\`manifest\` field. Filters must be produced via \`trigger.on(eventName, { ... })\` from ` +
-                `@voyant-travel/workflows - the public EventFilterDescriptor is the structural minimum, but ` +
-                `createApp() needs the manifest payload to register with the driver.`);
-        }
-        filterEntries.push({
-            id: candidate.manifest.id,
-            eventType: candidate.manifest.eventType,
-            manifest: candidate.manifest,
-            declaration: { target: { id: candidate.manifest.targetWorkflowId } },
-            targetWorkflowId: candidate.manifest.targetWorkflowId,
-        });
-    }
-    const manifest = await buildManifest({
-        projectId: args.projectId,
-        environment: args.environment,
-        workflows: args.collectedWorkflows.map(toManifestWorkflowDescriptor),
-        eventFilters: filterEntries,
-    });
-    await args.driver.registerManifest({
-        environment: args.environment,
-        manifest,
-    });
-    // Install one EventBus subscriber per unique eventType. Each subscriber
-    // forwards the envelope through `driver.ingestEvent(...)`, which routes
-    // through the same predicate/mapper machinery the HTTP ingest path uses.
-    const eventTypes = new Set(filterEntries.map((f) => f.manifest.eventType));
-    for (const eventType of eventTypes) {
-        args.eventBus.subscribe(eventType, async (envelope) => {
-            const stamped = ensureMetadataEventId(envelope);
-            // Let ingest failures propagate: the EventBus catches every subscriber
-            // throw (the emitter and sibling handlers stay unaffected per its
-            // fire-and-forget contract) AND routes it through `onSubscriberError`, so
-            // a misbehaving driver / network glitch is both logged and reported via
-            // the framework reporter — instead of being swallowed here (RFC #1553).
-            await args.driver.ingestEvent({
-                environment: args.environment,
-                envelope: stamped,
-            });
-        });
-    }
-}
-/**
- * Adapt the framework's `ModuleContainer` to a read-only `ServiceResolver`.
- */
-export function containerToServiceResolver(container) {
-    return {
-        resolve(name) {
-            return container.resolve(name);
-        },
-        has(name) {
-            return container.has(name);
-        },
-    };
-}
-/**
- * Adapt the framework's optional `LoggerProvider` to the workflow driver logger.
- */
-export function makeFrameworkLogger(loggerProvider) {
-    void loggerProvider;
-    return (level, msg, data) => {
-        const fn = level === "error"
-            ? console.error
-            : level === "warn"
-                ? console.warn
-                : level === "debug"
-                    ? console.debug
-                    : console.log;
-        if (data !== undefined)
-            fn(`[voyant] ${msg}`, data);
-        else
-            fn(`[voyant] ${msg}`);
-    };
-}
-function ensureMetadataEventId(envelope) {
-    const metadata = envelope.metadata;
-    if (metadata !== undefined &&
-        metadata !== null &&
-        typeof metadata === "object" &&
-        typeof metadata.eventId === "string" &&
-        (metadata.eventId.length ?? 0) > 0) {
-        return envelope;
-    }
-    const eventId = `evt_${Date.now().toString(36)}_${Math.floor(Math.random() * 1_000_000)
-        .toString(36)
-        .padStart(4, "0")}`;
-    return {
-        ...envelope,
-        metadata: {
-            ...(metadata ?? {}),
-            eventId,
-        },
-    };
-}