@voyant-travel/framework 0.1.0 → 0.2.0

package/dist/composition.js

@@ -0,0 +1,404 @@
+/**
+ * The standard Voyant runtime composition registry — the package-owned half of
+ * `OPERATOR_RUNTIME_MANIFEST`'s factories.
+ *
+ * agent-quality: file-size exception -- this is the framework's single
+ * composition source of truth (the FrameworkProviders contract + one factory
+ * entry per standard module/extension). Keeping the provider interface + the
+ * registry in one file is intentional; the length scales with the standard
+ * module count, not with logic complexity — mirroring the deployment's
+ * `composition.ts` rationale.
+ *
+ * Workstream B of the consolidated-deployments RFC relocates the deployment's
+ * `operatorComposition` registry here, one classified-as-standard family group
+ * at a time (see `operator-registry-classification.md`). A deployment spreads
+ * this into its own registry:
+ *
+ *     export const operatorComposition: CompositionRegistry<OperatorCapabilities> = {
+ *       modules:    { ...frameworkComposition.modules,    ...deploymentLocal },
+ *       extensions: { ...frameworkComposition.extensions, ...deploymentLocal },
+ *     }
+ *
+ * so `composeFromManifest` always sees one complete registry while the
+ * deployment object shrinks PR by PR.
+ *
+ * The factories read only the framework-owned {@link FrameworkProviders} surface
+ * off `ctx.capabilities` — never a deployment file, never a baked provider
+ * choice (Netopia et al. stay injected). Because `OperatorCapabilities extends
+ * FrameworkProviders` and factory params are contravariant, a
+ * `ModuleFactory<FrameworkProviders>` slots cleanly into the deployment's wider
+ * `CompositionRegistry<OperatorCapabilities>`.
+ *
+ * Provider field types are anchored to the package option types they feed
+ * (`NonNullable<XOptions["field"]>`) or to a package service (`typeof
+ * relationshipsService`), so they can't drift from the contracts the factories
+ * pass them into.
+ */
+import { actionLedgerHonoModule } from "@voyant-travel/action-ledger";
+import { bookingsSupplierExtension, createBookingsHonoModule, } from "@voyant-travel/bookings";
+import { bookingsExtrasRoutes } from "@voyant-travel/bookings/extras";
+import { createBookingRequirementsHonoModule, } from "@voyant-travel/bookings/requirements";
+import { createCatalogSearchHonoModule, executeSemanticSearch, } from "@voyant-travel/catalog";
+import { createCommerceHonoModules, createCommerceStorefrontOfferResolvers, } from "@voyant-travel/commerce";
+import { distributionBookingExtension, distributionHonoModule, externalRefsHonoModule, suppliersHonoModule, } from "@voyant-travel/distribution";
+import { bookingsCreateExtension, createBookingTaxHonoExtension, createFinanceHonoModule, } from "@voyant-travel/finance";
+import { createPublicDocumentDeliveryHonoModule } from "@voyant-travel/hono";
+import { identityHonoModule } from "@voyant-travel/identity";
+import { inventoryBookingExtension, inventoryHonoModule } from "@voyant-travel/inventory";
+import { inventoryAuthoringExtension } from "@voyant-travel/inventory/authoring/extension";
+import { inventoryExtrasRoutes } from "@voyant-travel/inventory/extras";
+import { CONTRACT_DOCUMENT_ROUTE_PATHS, createLegalHonoModule, } from "@voyant-travel/legal";
+import { createDefaultBookingDocumentAttachment, createNotificationService, createNotificationsHonoModule, notificationsService, } from "@voyant-travel/notifications";
+import { operationsHonoModule } from "@voyant-travel/operations";
+import { resolveBookingTaxSettings, updateBookingTaxSettings, } from "@voyant-travel/operator-settings";
+import { createOperatorSettingsHonoModule } from "@voyant-travel/operator-settings/hono-module";
+import { createQuotesHonoModule, quotesBookingExtension } from "@voyant-travel/quotes";
+import { createRelationshipsHonoModule, } from "@voyant-travel/relationships";
+import { createStorefrontHonoModule, } from "@voyant-travel/storefront";
+import { createCustomerPortalHonoModule } from "@voyant-travel/storefront/customer-portal";
+import { createStorefrontVerificationHonoModule, } from "@voyant-travel/storefront/verification";
+import { createTripsHonoModule } from "@voyant-travel/trips";
+import { Hono } from "hono";
+/**
+ * Combined "extras" surface — inventory + bookings package extras routes mounted
+ * on one module. Pure composition of package route sets (no providers); the
+ * deployment used to build this inline.
+ */
+const extrasHonoModule = {
+    module: { name: "extras" },
+    routes: new Hono().route("/", inventoryExtrasRoutes).route("/", bookingsExtrasRoutes),
+};
+// Stable absolute route matchers for the lazy `operator/*` standard families
+// (Tier 4). The framework owns the URL contract; the deployment injects only
+// the `load` closure that wires its providers into the route bundle.
+const CATALOG_BOOKING_ROUTE_PATHS = [
+    "/v1/admin/catalog/quote",
+    "/v1/admin/catalog/book",
+    "/v1/admin/catalog/drafts/:id",
+    "/v1/admin/catalog/holds/place",
+    "/v1/admin/catalog/holds/release",
+    "/v1/admin/catalog/slots",
+    "/v1/admin/catalog/orders",
+    "/v1/admin/catalog/orders/:id",
+    "/v1/admin/catalog/orders/:id/cancel",
+    "/v1/admin/bookings/:id/catalog-snapshot",
+    "/v1/public/catalog/quote",
+    "/v1/public/catalog/book",
+    "/v1/public/catalog/drafts/:id",
+    "/v1/public/catalog/holds/place",
+    "/v1/public/catalog/holds/release",
+    "/v1/public/catalog/slots",
+];
+const CATALOG_CONTENT_ROUTE_PATHS = [
+    "/v1/admin/products/:id/content",
+    "/v1/public/products/:id/content",
+    "/v1/admin/cruises/:id/content",
+    "/v1/public/cruises/:id/content",
+    "/v1/admin/accommodations/:id/content",
+    "/v1/public/accommodations/:id/content",
+];
+const MEDIA_ROUTE_PATHS = [
+    "/v1/admin/products/:id/brochure/generate",
+    "/v1/uploads",
+    "/v1/admin/uploads",
+    "/v1/uploads/video",
+    "/v1/admin/uploads/video",
+    "/v1/media/*",
+    "/v1/admin/media/*",
+];
+const PAYMENT_LINK_ROUTE_PATHS = [
+    "/v1/public/payment-link-config",
+    "/v1/public/payment-link/:sessionId/retry",
+    "/v1/public/payment-link/resolve",
+    "/v1/public/payment-link/:sessionId/start-card",
+    "/v1/public/payment-link/:sessionId/trip-summary",
+    "/v1/public/payment-link/:sessionId/booking-summary",
+    "/v1/public/bookings/:bookingId/checkout-status",
+];
+function optionalDateTime(value) {
+    if (!value)
+        return null;
+    return value instanceof Date ? value.toISOString() : value;
+}
+function toCheckoutNotificationDelivery(delivery) {
+    if (!delivery)
+        return null;
+    return {
+        id: delivery.id,
+        templateSlug: delivery.templateSlug,
+        channel: delivery.channel,
+        provider: delivery.provider,
+        status: delivery.status,
+        toAddress: delivery.toAddress,
+        subject: delivery.subject,
+        sentAt: optionalDateTime(delivery.sentAt),
+        failedAt: optionalDateTime(delivery.failedAt),
+        errorMessage: delivery.errorMessage,
+    };
+}
+function toCheckoutReminderRun(run) {
+    return {
+        id: run.id,
+        reminderRuleId: run.reminderRuleId,
+        reminderRuleSlug: run.reminderRule.slug,
+        reminderRuleName: run.reminderRule.name,
+        targetType: run.targetType,
+        targetId: run.targetId,
+        bookingId: run.links.bookingId,
+        paymentSessionId: run.links.paymentSessionId,
+        notificationDeliveryId: run.links.notificationDeliveryId,
+        status: run.status,
+        deliveryStatus: run.delivery?.status ?? null,
+        channel: run.delivery?.channel ?? run.reminderRule.channel,
+        provider: run.delivery?.provider ?? run.reminderRule.provider ?? null,
+        recipient: run.recipient,
+        scheduledFor: run.scheduledFor,
+        processedAt: run.processedAt,
+        errorMessage: run.errorMessage,
+        relativeDaysFromDueDate: null,
+        createdAt: run.createdAt,
+    };
+}
+/**
+ * Standard module/extension factories owned by the framework. Keyed by the same
+ * manifest specifiers as `FRAMEWORK_RUNTIME_MANIFEST`; a deployment spreads this
+ * into its registry (see file header).
+ *
+ * - Tier 1: the pure singleton modules — no providers, no deployment imports.
+ * - Tier 2: capability-shaped `@voyant-travel/*` modules — read injected
+ *   providers off `ctx.capabilities`.
+ */
+export const frameworkComposition = {
+    modules: {
+        // Tier 1 — pure singletons.
+        "@voyant-travel/action-ledger": () => actionLedgerHonoModule,
+        "@voyant-travel/relationships": ({ capabilities }) => createRelationshipsHonoModule({ customFields: capabilities.customFields }),
+        "@voyant-travel/quotes": () => createQuotesHonoModule(),
+        "@voyant-travel/operations": () => operationsHonoModule,
+        "@voyant-travel/identity": () => identityHonoModule,
+        "@voyant-travel/distribution": () => [
+            externalRefsHonoModule,
+            distributionHonoModule,
+            suppliersHonoModule,
+        ],
+        "@voyant-travel/commerce": () => createCommerceHonoModules(),
+        "@voyant-travel/inventory": () => inventoryHonoModule,
+        "@voyant-travel/inventory/extras": () => extrasHonoModule,
+        "@voyant-travel/bookings/requirements": ({ capabilities }) => createBookingRequirementsHonoModule({
+            publicRoutes: {
+                resolveProductSnapshot: capabilities.resolveBookingRequirementsProductSnapshot,
+            },
+        }),
+        // Tier 2 — capability-shaped modules (providers injected via ctx).
+        "@voyant-travel/catalog": ({ capabilities }) => createCatalogSearchHonoModule({
+            resolveRuntime: capabilities.resolveCatalogRuntime,
+            executeSearch: ({ adapter, embeddings, slice, request }) => executeSemanticSearch({
+                adapter,
+                embeddings: embeddings,
+                slice,
+                request,
+            }),
+        }),
+        "@voyant-travel/storefront": ({ capabilities }) => createStorefrontHonoModule({
+            offers: createCommerceStorefrontOfferResolvers(),
+            // Async booking-bootstrap intents (queued write pipeline, RFC
+            // voyant#1687 §3.2) — the handler runs on the app bus with
+            // outbox-grade retries; the */2min cron sweeps stale intents.
+            bookingIntents: { resolveDb: capabilities.resolveDb },
+            intake: { persistence: capabilities.storefrontIntakePersistence },
+        }),
+        "@voyant-travel/finance": ({ capabilities }) => createFinanceHonoModule({
+            resolveDocumentDownloadUrl: (bindings, storageKey) => capabilities.resolveDocumentDownloadUrl(bindings, storageKey),
+            resolveInvoiceExchangeRateResolver: capabilities.createInvoiceExchangeRateResolver,
+            resolveInvoiceSettlementPollers: capabilities.createInvoiceSettlementPollers,
+            invoiceDueDateResolver: ({ issueDate, dueDate, bookingPaymentSchedule }) => bookingPaymentSchedule && dueDate < issueDate ? issueDate : dueDate,
+            resolveNotificationDispatcher: (bindings) => {
+                const providers = capabilities.resolveNotificationProviders(bindings);
+                if (providers.length === 0)
+                    return null;
+                const dispatcher = createNotificationService(providers);
+                return {
+                    sendInvoiceNotification: async (db, invoiceId, input) => toCheckoutNotificationDelivery(await notificationsService.sendInvoiceNotification(db, dispatcher, invoiceId, input)),
+                    sendPaymentSessionNotification: async (db, paymentSessionId, input) => toCheckoutNotificationDelivery(await notificationsService.sendPaymentSessionNotification(db, dispatcher, paymentSessionId, input)),
+                };
+            },
+            resolvePaymentStarters: () => ({
+                netopia: capabilities.netopiaCheckoutStarter,
+            }),
+            resolveBankTransferDetails: capabilities.resolveBankTransferDetails,
+            resolvePublicCheckoutBaseUrl: capabilities.resolvePublicCheckoutBaseUrl,
+            listBookingReminderRuns: async (db, bookingId, query) => {
+                const result = await notificationsService.listReminderRuns(db, {
+                    bookingId,
+                    status: query.status,
+                    limit: query.limit,
+                    offset: query.offset,
+                });
+                return {
+                    data: result.data.map(toCheckoutReminderRun),
+                    total: result.total,
+                    limit: result.limit,
+                    offset: result.offset,
+                };
+            },
+        }),
+        "@voyant-travel/bookings": ({ capabilities }) => createBookingsHonoModule({
+            resolveTravelSnapshot: (db, personId, { kms }) => capabilities.relationshipsService.loadPersonTravelSnapshot(db, personId, { kms }),
+            resolveBillingPerson: async (db, contact, ctx) => {
+                const person = await capabilities.relationshipsService.upsertPersonFromContact(db, contact, {
+                    source: ctx.source,
+                    sourceRef: ctx.sourceRef,
+                });
+                return person?.id ?? null;
+            },
+            resolveTravelerPerson: async (db, contact, ctx) => {
+                const person = await capabilities.relationshipsService.upsertPersonFromContact(db, contact, {
+                    source: ctx.source,
+                    sourceRef: ctx.sourceRef,
+                    requireContactPoint: true,
+                });
+                return person?.id ?? null;
+            },
+            resolveBillingPersonById: async (db, personId) => (await capabilities.relationshipsService.getPersonById(db, personId)) != null,
+            resolveBillingOrganizationById: async (db, organizationId) => (await capabilities.relationshipsService.getOrganizationById(db, organizationId)) != null,
+            closePaymentSchedulesForBooking: capabilities.closePaymentSchedulesForBooking,
+            customFields: capabilities.customFields,
+        }),
+        "@voyant-travel/public-document-delivery": ({ capabilities }) => createPublicDocumentDeliveryHonoModule({
+            // Same storage backend as legal documents; the unknown-bindings
+            // adapter keeps the provider contract uniform (the narrow-bindings
+            // `createDocumentStorage` is retired in the deployment).
+            resolveStorage: capabilities.createOperatorDocumentStorage,
+        }),
+        "@voyant-travel/notifications": ({ capabilities }) => createNotificationsHonoModule({
+            resolveProviders: capabilities.resolveNotificationProviders,
+            resolvePublicCheckoutBaseUrl: capabilities.resolvePublicCheckoutBaseUrl,
+            resolveDocumentAttachmentResolver: (bindings) => async (document) => {
+                if (document.storageKey) {
+                    const contentBase64 = await capabilities.readDocumentContentBase64(bindings, document.storageKey);
+                    if (contentBase64) {
+                        return {
+                            filename: document.name,
+                            contentBase64,
+                            contentType: document.mimeType ?? undefined,
+                        };
+                    }
+                    const path = await capabilities.resolveDocumentDownloadUrl(bindings, document.storageKey);
+                    if (path) {
+                        return {
+                            filename: document.name,
+                            path,
+                            contentType: document.mimeType ?? undefined,
+                        };
+                    }
+                }
+                return createDefaultBookingDocumentAttachment(document);
+            },
+            resolveDb: capabilities.resolveDb,
+            autoConfirmAndDispatch: { enabled: true, templateSlug: "booking-confirmation" },
+        }),
+        "@voyant-travel/legal": ({ capabilities }) => createLegalHonoModule({
+            resolveDb: capabilities.resolveDb,
+            resolveDocumentDownloadUrl: (bindings, storageKey) => capabilities.resolveDocumentDownloadUrl(bindings, storageKey),
+            resolveDocumentStorage: capabilities.createOperatorDocumentStorage,
+            resolveDocumentGenerator: capabilities.resolveContractDocumentGenerator,
+            resolveBookingPiiService: capabilities.createBookingPiiService,
+            autoGenerateContractOnConfirmed: capabilities.autoGenerateContractOnConfirmed,
+        }),
+        "@voyant-travel/storefront/customer-portal": ({ capabilities }) => createCustomerPortalHonoModule({
+            resolveDocumentDownloadUrl: (bindings, storageKey) => capabilities.resolveDocumentDownloadUrl(bindings, storageKey),
+        }),
+        "@voyant-travel/storefront/verification": ({ capabilities }) => createStorefrontVerificationHonoModule({
+            resolveProviders: capabilities.resolveNotificationProviders,
+            email: { subject: "Your verification code" },
+        }),
+        "@voyant-travel/trips": ({ capabilities }) => createTripsHonoModule({
+            ...capabilities.createTripsRoutesOptions(),
+            publicRoutes: true,
+        }),
+        // Standard settings module — schema-owning + lazy absolute-path routes, no
+        // providers (reads its own tables). Stage 2 of the operator-settings
+        // extraction; previously a deployment-local module.
+        "@voyant-travel/operator-settings": () => createOperatorSettingsHonoModule(),
+        // Tier 4 — lazy `operator/*` standard families. The framework owns the
+        // manifest entry + path matchers; the deployment injects the `load` closure
+        // that wires its providers into the package-owned route bundle.
+        "@voyant-travel/flights": ({ capabilities }) => ({
+            module: { name: "flights" },
+            lazyAdminRoutes: capabilities.loadFlightAdminRoutes,
+        }),
+        "operator/mcp": ({ capabilities }) => ({
+            module: { name: "mcp" },
+            lazyAdminRoutes: capabilities.loadMcpAdminRoutes,
+        }),
+        "operator/catalog-booking": ({ capabilities }) => ({
+            module: { name: "catalog-booking" },
+            lazyRoutes: {
+                paths: CATALOG_BOOKING_ROUTE_PATHS,
+                load: capabilities.loadCatalogBookingRoutes,
+            },
+        }),
+        "operator/catalog-content": ({ capabilities }) => ({
+            module: { name: "catalog-content" },
+            lazyRoutes: {
+                paths: CATALOG_CONTENT_ROUTE_PATHS,
+                load: capabilities.loadCatalogContentRoutes,
+            },
+        }),
+        "operator/media": ({ capabilities }) => ({
+            module: { name: "media" },
+            lazyRoutes: { paths: MEDIA_ROUTE_PATHS, load: capabilities.loadMediaRoutes },
+        }),
+        "operator/payment-link": ({ capabilities }) => ({
+            module: { name: "payment-link" },
+            lazyRoutes: { paths: PAYMENT_LINK_ROUTE_PATHS, load: capabilities.loadPaymentLinkRoutes },
+        }),
+        "operator/contract-document": ({ capabilities }) => ({
+            module: { name: "contract-document" },
+            lazyRoutes: {
+                paths: CONTRACT_DOCUMENT_ROUTE_PATHS,
+                load: capabilities.loadContractDocumentRoutes,
+            },
+        }),
+    },
+    extensions: {
+        // Tier 3 — pure singleton extensions (no providers).
+        "@voyant-travel/bookings/booking-supplier-extension": () => bookingsSupplierExtension,
+        "@voyant-travel/finance/bookings-create-extension": () => bookingsCreateExtension,
+        "@voyant-travel/inventory/booking-extension": () => inventoryBookingExtension,
+        "@voyant-travel/inventory/authoring/extension": () => inventoryAuthoringExtension,
+        "@voyant-travel/quotes/booking-extension": () => quotesBookingExtension,
+        "@voyant-travel/distribution": () => distributionBookingExtension,
+        // Injection-shaped extensions — deployment-specific builders/readers via ctx.
+        "@voyant-travel/distribution/channel-push-extension": ({ capabilities }) => capabilities.createChannelPushExtension(),
+        // Booking-tax settings are read straight from the standard
+        // @voyant-travel/operator-settings package — no per-deployment injection.
+        "@voyant-travel/finance/booking-tax-extension": () => createBookingTaxHonoExtension({ resolveBookingTaxSettings, updateBookingTaxSettings }),
+        // Tier 4 — lazy `operator/*` standard extensions. The framework owns the
+        // `extension` metadata + publicPath; the deployment injects builders/loaders.
+        "operator/booking-schedule-extension": ({ capabilities }) => capabilities.createBookingScheduleExtension(),
+        "operator/quote-version-snapshot-extension": ({ capabilities }) => capabilities.createQuoteVersionSnapshotExtension(),
+        "operator/booking-maintenance-extension": ({ capabilities }) => ({
+            extension: { name: "booking-maintenance", module: "bookings" },
+            lazyAdminRoutes: capabilities.loadBookingMaintenanceRoutes,
+        }),
+        "operator/action-ledger-health-extension": ({ capabilities }) => ({
+            extension: { name: "action-ledger-health", module: "action-ledger" },
+            lazyAdminRoutes: capabilities.loadActionLedgerHealthRoutes,
+        }),
+        "operator/proposal-extension": ({ capabilities }) => ({
+            extension: { name: "proposal", module: "quote-versions" },
+            publicPath: "proposals",
+            lazyAdminRoutes: capabilities.loadProposalAdminRoutes,
+            lazyPublicRoutes: capabilities.loadProposalPublicRoutes,
+        }),
+        "operator/catalog-offers-extension": ({ capabilities }) => ({
+            extension: { name: "catalog-offers", module: "catalog" },
+            lazyAdminRoutes: capabilities.loadCatalogOffersRoutes,
+        }),
+        "operator/catalog-checkout-extension": ({ capabilities }) => ({
+            extension: { name: "catalog-checkout", module: "catalog" },
+            lazyPublicRoutes: capabilities.loadCatalogCheckoutRoutes,
+        }),
+    },
+};

package/dist/create-app.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `createVoyantApp` — the framework's config-driven front door (Workstream B
+ * convergence).
+ *
+ * A standard deployment no longer hand-assembles a manifest + registry. It calls
+ * this with its injected {@link FrameworkProviders} and any deployment-local
+ * module/extension additions; the framework merges them onto the standard set
+ * (`FRAMEWORK_RUNTIME_MANIFEST` + `frameworkComposition`) and delegates to the
+ * lower-level `createApp` in `@voyant-travel/hono`.
+ *
+ *     export const app = createVoyantApp<CloudflareBindings, OperatorProviders>({
+ *       providers: buildOperatorProviders(),
+ *       modules:   deploymentLocalModules,   // e.g. invitations, operator-settings
+ *       db, workflows, outbox, publicPaths,  // unchanged VoyantApp config
+ *     })
+ *
+ * This is NOT the rejected "assembly kit": providers stay injected (never baked),
+ * and the assembly is the framework-owned standard set — not a bottom-up file dump.
+ *
+ * Scope (D.1): the standard profile is FIXED. This always mounts the full
+ * `FRAMEWORK_RUNTIME_MANIFEST` and only APPENDS the deployment's local
+ * `modules`/`extensions`; it does not consume `voyant.config` to remove standard
+ * modules. Subsetting the standard set is a later workstream — see `manifest.ts`.
+ */
+import { type CreateAppConfig, type VoyantBindings } from "@voyant-travel/hono";
+import type { ExtensionFactory, ModuleFactory } from "@voyant-travel/hono/composition";
+import { type FrameworkProviders } from "./composition.js";
+/**
+ * Config for {@link createVoyantApp}: the injected providers + deployment-local
+ * additions, plus everything else `createApp` takes (db, auth, workflows,
+ * outbox, publicPaths, …) — minus the `manifest`/`registry`/`capabilities` the
+ * framework now assembles for you.
+ */
+export interface CreateVoyantAppConfig<TBindings extends VoyantBindings, TProviders extends FrameworkProviders> extends Omit<CreateAppConfig<TBindings, TProviders>, "manifest" | "registry" | "capabilities"> {
+    /** The deployment-injected provider surface (a `FrameworkProviders` superset). */
+    providers: TProviders;
+    /** Deployment-local module factories, appended after the standard set. */
+    modules?: Record<string, ModuleFactory<TProviders>>;
+    /** Deployment-local extension factories, appended after the standard set. */
+    extensions?: Record<string, ExtensionFactory<TProviders>>;
+}
+/**
+ * Assemble the standard manifest + registry (framework-owned) with the
+ * deployment's local additions, then build the app via `@voyant-travel/hono`'s
+ * `createApp`. Standard families keep their `FRAMEWORK_RUNTIME_MANIFEST` order;
+ * local additions mount after them.
+ */
+export declare function createVoyantApp<TBindings extends VoyantBindings, TProviders extends FrameworkProviders>(config: CreateVoyantAppConfig<TBindings, TProviders>): import("hono").Hono<{
+    Bindings: TBindings;
+    Variables: import("@voyant-travel/hono").VoyantVariables;
+}, import("hono/types").BlankSchema, "/"> & import("@voyant-travel/hono/app").VoyantAppExtensions<TBindings>;
+//# sourceMappingURL=create-app.d.ts.map

package/dist/create-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-app.d.ts","sourceRoot":"","sources":["../src/create-app.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,KAAK,eAAe,EAAa,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAC1F,OAAO,KAAK,EAEV,gBAAgB,EAChB,aAAa,EACd,MAAM,iCAAiC,CAAA;AACxC,OAAO,EAAE,KAAK,kBAAkB,EAAwB,MAAM,kBAAkB,CAAA;AAGhF;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB,CACpC,SAAS,SAAS,cAAc,EAChC,UAAU,SAAS,kBAAkB,CACrC,SAAQ,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,cAAc,CAAC;IAC9F,kFAAkF;IAClF,SAAS,EAAE,UAAU,CAAA;IACrB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;IACnD,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAA;CAC1D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,SAAS,cAAc,EAChC,UAAU,SAAS,kBAAkB,EACrC,MAAM,EAAE,qBAAqB,CAAC,SAAS,EAAE,UAAU,CAAC;;;6GA2BrD"}

package/dist/create-app.js

@@ -0,0 +1,59 @@
+/**
+ * `createVoyantApp` — the framework's config-driven front door (Workstream B
+ * convergence).
+ *
+ * A standard deployment no longer hand-assembles a manifest + registry. It calls
+ * this with its injected {@link FrameworkProviders} and any deployment-local
+ * module/extension additions; the framework merges them onto the standard set
+ * (`FRAMEWORK_RUNTIME_MANIFEST` + `frameworkComposition`) and delegates to the
+ * lower-level `createApp` in `@voyant-travel/hono`.
+ *
+ *     export const app = createVoyantApp<CloudflareBindings, OperatorProviders>({
+ *       providers: buildOperatorProviders(),
+ *       modules:   deploymentLocalModules,   // e.g. invitations, operator-settings
+ *       db, workflows, outbox, publicPaths,  // unchanged VoyantApp config
+ *     })
+ *
+ * This is NOT the rejected "assembly kit": providers stay injected (never baked),
+ * and the assembly is the framework-owned standard set — not a bottom-up file dump.
+ *
+ * Scope (D.1): the standard profile is FIXED. This always mounts the full
+ * `FRAMEWORK_RUNTIME_MANIFEST` and only APPENDS the deployment's local
+ * `modules`/`extensions`; it does not consume `voyant.config` to remove standard
+ * modules. Subsetting the standard set is a later workstream — see `manifest.ts`.
+ */
+import { createApp } from "@voyant-travel/hono";
+import { frameworkComposition } from "./composition.js";
+import { FRAMEWORK_RUNTIME_MANIFEST } from "./manifest.js";
+/**
+ * Assemble the standard manifest + registry (framework-owned) with the
+ * deployment's local additions, then build the app via `@voyant-travel/hono`'s
+ * `createApp`. Standard families keep their `FRAMEWORK_RUNTIME_MANIFEST` order;
+ * local additions mount after them.
+ */
+export function createVoyantApp(config) {
+    const { providers, modules = {}, extensions = {}, ...rest } = config;
+    const registry = {
+        // The framework factories read only the `FrameworkProviders` slice; a
+        // `ModuleFactory<FrameworkProviders>` is assignable to
+        // `ModuleFactory<TProviders>` (factory params are contravariant), so the
+        // standard set composes against the deployment's wider providers.
+        modules: {
+            ...frameworkComposition.modules,
+            ...modules,
+        },
+        extensions: {
+            ...frameworkComposition.extensions,
+            ...extensions,
+        },
+    };
+    return createApp({
+        ...rest,
+        manifest: {
+            modules: [...FRAMEWORK_RUNTIME_MANIFEST.modules, ...Object.keys(modules)],
+            extensions: [...FRAMEWORK_RUNTIME_MANIFEST.extensions, ...Object.keys(extensions)],
+        },
+        registry,
+        capabilities: providers,
+    });
+}

package/dist/discover-modules.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Deployment-local module + extension discovery (consolidated-deployments RFC —
+ * the "20%" extension seams: *custom module* and *custom route on an existing
+ * module*, neither requiring a fork).
+ *
+ * A deployment drops a unit into a conventional directory and it is auto-mounted
+ * — no edit to a framework-owned file, no hand-wiring in the deployment's
+ * composition:
+ *
+ *   - `src/modules/<name>/index.ts`    → a new module (own routes + schema)
+ *   - `src/extensions/<name>/index.ts` → a {@link HonoExtension} adding routes to
+ *                                        an EXISTING module's surface
+ *
+ * Discovery is **build-time**: the deployment feeds a Vite
+ * `import.meta.glob("./modules/*\/index.ts", { eager: true })` (statically
+ * compiled to static imports — Workers-safe) into {@link modulesFromGlob} /
+ * {@link extensionsFromGlob}, which key each unit by its `<name>` directory
+ * segment.
+ *
+ *     // src/api/composition.ts (deployment-owned)
+ *     const modules = modulesFromGlob<OperatorCapabilities>(
+ *       import.meta.glob("../modules/*\/index.ts", { eager: true }),
+ *     )
+ *     const extensions = extensionsFromGlob<OperatorCapabilities>(
+ *       import.meta.glob("../extensions/*\/index.ts", { eager: true }),
+ *     )
+ *
+ *     // src/modules/loyalty/index.ts
+ *     export default defineDeploymentModule({ module: { name: "loyalty" }, adminRoutes })
+ *     // src/extensions/booking-notes/index.ts
+ *     export default defineDeploymentExtension({
+ *       extension: { module: "bookings" }, adminRoutes,  // → /v1/admin/bookings/*
+ *     })
+ *
+ * Schema owned by a custom module/extension (`<dir>/<name>/schema.ts`) is picked
+ * up by the deployment's drizzle config glob (a *deployment* migration source,
+ * applied after the framework bundle by the D.1 collector).
+ */
+import type { ExtensionFactory, ModuleFactory } from "@voyant-travel/hono/composition";
+import type { HonoExtension, HonoModule } from "@voyant-travel/hono/module";
+import type { FrameworkProviders } from "./composition.js";
+/** A deployment module declaration: a ready unit, or a factory that builds one. */
+export type DeploymentModuleDeclaration<TProviders> = HonoModule | HonoModule[] | ModuleFactory<TProviders>;
+/** A deployment extension declaration: a ready unit, or a factory that builds one. */
+export type DeploymentExtensionDeclaration<TProviders> = HonoExtension | ExtensionFactory<TProviders>;
+/**
+ * Normalize a deployment-local module declaration into a {@link ModuleFactory}.
+ * Accepts a ready {@link HonoModule} (or array) or a factory; returns a factory
+ * either way. Use it as the `export default` of a `src/modules/<name>/index.ts`.
+ */
+export declare function defineDeploymentModule<TProviders = FrameworkProviders>(declaration: DeploymentModuleDeclaration<TProviders>): ModuleFactory<TProviders>;
+/**
+ * Normalize a deployment-local extension declaration into an
+ * {@link ExtensionFactory}. Accepts a ready {@link HonoExtension} or a factory.
+ * Use it as the `export default` of a `src/extensions/<name>/index.ts`.
+ */
+export declare function defineDeploymentExtension<TProviders = FrameworkProviders>(declaration: DeploymentExtensionDeclaration<TProviders>): ExtensionFactory<TProviders>;
+/** A Vite `import.meta.glob(..., { eager: true })` result: path → module namespace. */
+export type EagerModuleGlob = Record<string, unknown>;
+/**
+ * Build a deployment-local **module** registry from a Vite `import.meta.glob`
+ * (eager) of `src/modules/<name>/index.ts` files. Each entry's `default` export
+ * is a {@link HonoModule} or {@link ModuleFactory} (wrap with
+ * {@link defineDeploymentModule}); the registry key is the `<name>` directory
+ * segment, which becomes the module's composition specifier.
+ *
+ * @throws if a matched file has no default export.
+ */
+export declare function modulesFromGlob<TProviders = FrameworkProviders>(glob: EagerModuleGlob): Record<string, ModuleFactory<TProviders>>;
+/**
+ * Build a deployment-local **extension** registry from a Vite `import.meta.glob`
+ * (eager) of `src/extensions/<name>/index.ts` files. Each entry's `default`
+ * export is a {@link HonoExtension} or {@link ExtensionFactory} (wrap with
+ * {@link defineDeploymentExtension}); the registry key is the `<name>` directory
+ * segment.
+ *
+ * @throws if a matched file has no default export.
+ */
+export declare function extensionsFromGlob<TProviders = FrameworkProviders>(glob: EagerModuleGlob): Record<string, ExtensionFactory<TProviders>>;
+//# sourceMappingURL=discover-modules.d.ts.map

package/dist/discover-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-modules.d.ts","sourceRoot":"","sources":["../src/discover-modules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAC3E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE1D,mFAAmF;AACnF,MAAM,MAAM,2BAA2B,CAAC,UAAU,IAC9C,UAAU,GACV,UAAU,EAAE,GACZ,aAAa,CAAC,UAAU,CAAC,CAAA;AAE7B,sFAAsF;AACtF,MAAM,MAAM,8BAA8B,CAAC,UAAU,IACjD,aAAa,GACb,gBAAgB,CAAC,UAAU,CAAC,CAAA;AAEhC;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,GAAG,kBAAkB,EACpE,WAAW,EAAE,2BAA2B,CAAC,UAAU,CAAC,GACnD,aAAa,CAAC,UAAU,CAAC,CAE3B;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,GAAG,kBAAkB,EACvE,WAAW,EAAE,8BAA8B,CAAC,UAAU,CAAC,GACtD,gBAAgB,CAAC,UAAU,CAAC,CAE9B;AAED,uFAAuF;AACvF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAErD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,GAAG,kBAAkB,EAC7D,IAAI,EAAE,eAAe,GACpB,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,CAI3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,GAAG,kBAAkB,EAChE,IAAI,EAAE,eAAe,GACpB,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAO9C"}