@voyant-travel/framework 0.1.0 → 0.2.1

package/dist/discover-modules.js

@@ -0,0 +1,104 @@
+/**
+ * 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).
+ */
+/**
+ * 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 function defineDeploymentModule(declaration) {
+    return typeof declaration === "function" ? declaration : () => declaration;
+}
+/**
+ * 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 function defineDeploymentExtension(declaration) {
+    return typeof declaration === "function" ? declaration : () => declaration;
+}
+/**
+ * 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 function modulesFromGlob(glob) {
+    return discoverFromGlob(glob, "modules", (declaration) => defineDeploymentModule(declaration));
+}
+/**
+ * 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 function extensionsFromGlob(glob) {
+    return discoverFromGlob(glob, "extensions", (declaration) => defineDeploymentExtension(declaration));
+}
+/**
+ * Shared scanner: map an eager glob of `<dir>/<name>/index.ts` files to a
+ * `{ <name>: normalize(default) }` registry, ignoring non-matching paths.
+ */
+function discoverFromGlob(glob, dir, normalize) {
+    const registry = {};
+    for (const [path, namespace] of Object.entries(glob)) {
+        const name = nameFromPath(path, dir);
+        if (!name) {
+            continue;
+        }
+        const declaration = namespace.default;
+        if (declaration == null) {
+            throw new Error(`deployment ${dir.replace(/s$/, "")} "${path}" has no default export — ` +
+                `add \`export default ${dir === "modules" ? "defineDeploymentModule" : "defineDeploymentExtension"}(...)\` ` +
+                `to src/${dir}/${name}/index.ts`);
+        }
+        registry[name] = normalize(declaration);
+    }
+    return registry;
+}
+/** Extract the `<name>` segment from a `.../<dir>/<name>/index.{ts,tsx,…}` path. */
+function nameFromPath(path, dir) {
+    const match = path.match(new RegExp(`/${dir}/([^/]+)/index\\.[cm]?tsx?$`));
+    return match ? match[1] : null;
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=discover-modules.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discover-modules.test.d.ts","sourceRoot":"","sources":["../src/discover-modules.test.ts"],"names":[],"mappings":""}

package/dist/discover-modules.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { defineDeploymentExtension, defineDeploymentModule, extensionsFromGlob, modulesFromGlob, } from "./discover-modules.js";
+const loyalty = { module: { name: "loyalty" } };
+const bookingNotes = { extension: { name: "booking-notes", module: "bookings" } };
+// The factories under test ignore capabilities; cast a minimal context.
+const ctx = { capabilities: {}, options: {} };
+describe("defineDeploymentModule", () => {
+    it("wraps a ready HonoModule in a factory", () => {
+        const factory = defineDeploymentModule(loyalty);
+        expect(typeof factory).toBe("function");
+        expect(factory(ctx)).toBe(loyalty);
+    });
+    it("passes a factory through unchanged (identity)", () => {
+        const original = () => loyalty;
+        expect(defineDeploymentModule(original)).toBe(original);
+    });
+    it("supports a HonoModule[] declaration", () => {
+        const pair = [loyalty, { module: { name: "loyalty-admin" } }];
+        expect(defineDeploymentModule(pair)(ctx)).toBe(pair);
+    });
+});
+describe("modulesFromGlob", () => {
+    it("keys each module by its <name> directory segment", () => {
+        const registry = modulesFromGlob({
+            "../modules/loyalty/index.ts": { default: loyalty },
+            "../modules/gift-cards/index.ts": { default: () => ({ module: { name: "gift-cards" } }) },
+        });
+        expect(Object.keys(registry).sort()).toEqual(["gift-cards", "loyalty"]);
+        expect(registry.loyalty?.(ctx)).toBe(loyalty);
+    });
+    it("returns an empty registry for an empty glob (no custom modules)", () => {
+        expect(modulesFromGlob({})).toEqual({});
+    });
+    it("ignores paths that aren't a modules/<name>/index file", () => {
+        const registry = modulesFromGlob({
+            "../modules/loyalty/schema.ts": { default: {} },
+            "../lib/helper.ts": { default: {} },
+        });
+        expect(registry).toEqual({});
+    });
+    it("throws on a matched module with no default export", () => {
+        expect(() => modulesFromGlob({ "../modules/loyalty/index.ts": { named: 1 } })).toThrow(/no default export/);
+    });
+});
+describe("defineDeploymentExtension", () => {
+    it("wraps a ready HonoExtension in a factory", () => {
+        const factory = defineDeploymentExtension(bookingNotes);
+        expect(typeof factory).toBe("function");
+        expect(factory(ctx)).toBe(bookingNotes);
+    });
+    it("passes a factory through unchanged (identity)", () => {
+        const original = () => bookingNotes;
+        expect(defineDeploymentExtension(original)).toBe(original);
+    });
+});
+describe("extensionsFromGlob", () => {
+    it("keys each extension by its <name> directory segment", () => {
+        const registry = extensionsFromGlob({
+            "../extensions/booking-notes/index.ts": { default: bookingNotes },
+            "../extensions/order-tags/index.ts": {
+                default: () => ({ extension: { name: "order-tags", module: "orders" } }),
+            },
+        });
+        expect(Object.keys(registry).sort()).toEqual(["booking-notes", "order-tags"]);
+        expect(registry["booking-notes"]?.(ctx)).toBe(bookingNotes);
+    });
+    it("returns an empty registry for an empty glob (no custom extensions)", () => {
+        expect(extensionsFromGlob({})).toEqual({});
+    });
+    it("does not pick up modules (only matches the extensions dir)", () => {
+        expect(extensionsFromGlob({ "../modules/loyalty/index.ts": { default: loyalty } })).toEqual({});
+    });
+    it("throws on a matched extension with no default export", () => {
+        expect(() => extensionsFromGlob({ "../extensions/booking-notes/index.ts": { named: 1 } })).toThrow(/no default export/);
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `@voyant-travel/framework` — the Voyant framework BOM (bill of materials).
+ *
+ * This package's `dependencies` pin the exact tested runtime-module set. A
+ * deployment depends on **one** framework version instead of a matrix of
+ * per-package versions; `voyant upgrade` bumps it, and pnpm/npm resolve the
+ * pinned set transitively. The compatibility matrix is resolved *inside* the
+ * BOM — the deployment never sees it.
+ *
+ * This is deliberately NOT global lockstep: the runtime packages keep
+ * independent versions (only changed packages republish — no per-package npm
+ * email spam), and the BOM is the single thing that always tracks "the
+ * framework version".
+ *
+ * Beyond the BOM, the package also owns the standard runtime composition: the
+ * ordered manifest (`FRAMEWORK_RUNTIME_MANIFEST`) and the standard registry
+ * factories (`frameworkComposition`) a deployment spreads — Workstream B of the
+ * consolidated-deployments RFC.
+ */
+export { type FrameworkProviders, frameworkComposition } from "./composition.js";
+export { type CreateVoyantAppConfig, createVoyantApp } from "./create-app.js";
+export { type DeploymentExtensionDeclaration, type DeploymentModuleDeclaration, defineDeploymentExtension, defineDeploymentModule, type EagerModuleGlob, extensionsFromGlob, modulesFromGlob, } from "./discover-modules.js";
+export { FRAMEWORK_RUNTIME_MANIFEST, type FrameworkManifest } from "./manifest.js";
+export { FRAMEWORK_RUNTIME_PACKAGES, type FrameworkRuntimePackage, } from "./runtime-packages.generated.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,KAAK,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAChF,OAAO,EAAE,KAAK,qBAAqB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAC7E,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,EAChC,yBAAyB,EACzB,sBAAsB,EACtB,KAAK,eAAe,EACpB,kBAAkB,EAClB,eAAe,GAChB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,0BAA0B,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAClF,OAAO,EACL,0BAA0B,EAC1B,KAAK,uBAAuB,GAC7B,MAAM,iCAAiC,CAAA"}

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * `@voyant-travel/framework` — the Voyant framework BOM (bill of materials).
+ *
+ * This package's `dependencies` pin the exact tested runtime-module set. A
+ * deployment depends on **one** framework version instead of a matrix of
+ * per-package versions; `voyant upgrade` bumps it, and pnpm/npm resolve the
+ * pinned set transitively. The compatibility matrix is resolved *inside* the
+ * BOM — the deployment never sees it.
+ *
+ * This is deliberately NOT global lockstep: the runtime packages keep
+ * independent versions (only changed packages republish — no per-package npm
+ * email spam), and the BOM is the single thing that always tracks "the
+ * framework version".
+ *
+ * Beyond the BOM, the package also owns the standard runtime composition: the
+ * ordered manifest (`FRAMEWORK_RUNTIME_MANIFEST`) and the standard registry
+ * factories (`frameworkComposition`) a deployment spreads — Workstream B of the
+ * consolidated-deployments RFC.
+ */
+export { frameworkComposition } from "./composition.js";
+export { createVoyantApp } from "./create-app.js";
+export { defineDeploymentExtension, defineDeploymentModule, extensionsFromGlob, modulesFromGlob, } from "./discover-modules.js";
+export { FRAMEWORK_RUNTIME_MANIFEST } from "./manifest.js";
+export { FRAMEWORK_RUNTIME_PACKAGES, } from "./runtime-packages.generated.js";

package/dist/manifest.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The standard Voyant runtime composition manifest — the ordered set of
+ * package-delivered modules + extensions every operator deployment mounts.
+ *
+ * A deployment composes its full manifest by spreading this and appending its
+ * own deployment-local entries. Owning the standard ordering here means a new
+ * standard module added to the framework auto-joins the default set — the
+ * deployment doesn't re-list it.
+ *
+ * D.1 ships a FIXED standard profile: `createVoyantApp` always mounts this full
+ * set and only appends deployment-local modules/extensions — it does not yet
+ * consume `voyant.config` to pare the standard set down. Module subsetting is a
+ * later workstream; until then a deployment that must drop a standard module
+ * forks the manifest explicitly rather than configuring it away.
+ *
+ * Workstream B of the consolidated-deployments RFC: the standard registry's
+ * factories relocate into this package next; this is the manifest (the "which +
+ * order") moving first.
+ */
+export interface FrameworkManifest {
+    modules: readonly string[];
+    extensions: readonly string[];
+}
+export declare const FRAMEWORK_RUNTIME_MANIFEST: {
+    readonly modules: readonly ["@voyant-travel/action-ledger", "@voyant-travel/relationships", "@voyant-travel/quotes", "@voyant-travel/operations", "@voyant-travel/identity", "@voyant-travel/distribution", "@voyant-travel/inventory/extras", "@voyant-travel/bookings/requirements", "@voyant-travel/commerce", "@voyant-travel/inventory", "@voyant-travel/catalog", "@voyant-travel/bookings", "@voyant-travel/finance", "@voyant-travel/legal", "@voyant-travel/public-document-delivery", "@voyant-travel/notifications", "@voyant-travel/storefront", "@voyant-travel/storefront/customer-portal", "@voyant-travel/storefront/verification", "@voyant-travel/trips", "@voyant-travel/flights", "@voyant-travel/operator-settings", "operator/mcp", "operator/catalog-booking", "operator/catalog-content", "operator/media", "operator/payment-link", "operator/contract-document"];
+    readonly extensions: readonly ["@voyant-travel/bookings/booking-supplier-extension", "@voyant-travel/finance/bookings-create-extension", "@voyant-travel/inventory/booking-extension", "@voyant-travel/inventory/authoring/extension", "@voyant-travel/quotes/booking-extension", "@voyant-travel/distribution", "@voyant-travel/distribution/channel-push-extension", "@voyant-travel/finance/booking-tax-extension", "operator/booking-schedule-extension", "operator/quote-version-snapshot-extension", "operator/booking-maintenance-extension", "operator/action-ledger-health-extension", "operator/proposal-extension", "operator/catalog-offers-extension", "operator/catalog-checkout-extension"];
+};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1B,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B;AAED,eAAO,MAAM,0BAA0B;;;CAuDD,CAAA"}

package/dist/manifest.js

@@ -0,0 +1,56 @@
+export const FRAMEWORK_RUNTIME_MANIFEST = {
+    modules: [
+        "@voyant-travel/action-ledger",
+        "@voyant-travel/relationships",
+        "@voyant-travel/quotes",
+        "@voyant-travel/operations",
+        "@voyant-travel/identity",
+        "@voyant-travel/distribution",
+        "@voyant-travel/inventory/extras",
+        "@voyant-travel/bookings/requirements",
+        "@voyant-travel/commerce",
+        "@voyant-travel/inventory",
+        "@voyant-travel/catalog",
+        "@voyant-travel/bookings",
+        "@voyant-travel/finance",
+        "@voyant-travel/legal",
+        "@voyant-travel/public-document-delivery",
+        "@voyant-travel/notifications",
+        "@voyant-travel/storefront",
+        "@voyant-travel/storefront/customer-portal",
+        "@voyant-travel/storefront/verification",
+        "@voyant-travel/trips",
+        "@voyant-travel/flights",
+        "@voyant-travel/operator-settings",
+        // `operator/*` STANDARD families — routes are package-owned; they keep the
+        // `operator/*` specifier only because the deployment injects their provider
+        // wiring (see operator-registry-classification.md). The framework owns the
+        // factory (frameworkComposition) + manifest entry; the deployment injects
+        // the loaders. (operator/invitations + operator/operator-settings are
+        // genuinely deployment-local and stay appended in the deployment's manifest.)
+        "operator/mcp",
+        "operator/catalog-booking",
+        "operator/catalog-content",
+        "operator/media",
+        "operator/payment-link",
+        "operator/contract-document",
+    ],
+    extensions: [
+        "@voyant-travel/bookings/booking-supplier-extension",
+        "@voyant-travel/finance/bookings-create-extension",
+        "@voyant-travel/inventory/booking-extension",
+        "@voyant-travel/inventory/authoring/extension",
+        "@voyant-travel/quotes/booking-extension",
+        "@voyant-travel/distribution",
+        "@voyant-travel/distribution/channel-push-extension",
+        "@voyant-travel/finance/booking-tax-extension",
+        // `operator/*` STANDARD extensions (builders/loaders injected).
+        "operator/booking-schedule-extension",
+        "operator/quote-version-snapshot-extension",
+        "operator/booking-maintenance-extension",
+        "operator/action-ledger-health-extension",
+        "operator/proposal-extension",
+        "operator/catalog-offers-extension",
+        "operator/catalog-checkout-extension",
+    ],
+};

package/dist/runtime-packages.generated.d.ts

@@ -0,0 +1,3 @@
+export declare const FRAMEWORK_RUNTIME_PACKAGES: readonly ["@voyant-travel/action-ledger", "@voyant-travel/bookings", "@voyant-travel/catalog", "@voyant-travel/commerce", "@voyant-travel/distribution", "@voyant-travel/finance", "@voyant-travel/flights", "@voyant-travel/identity", "@voyant-travel/inventory", "@voyant-travel/legal", "@voyant-travel/notifications", "@voyant-travel/operations", "@voyant-travel/operator-settings", "@voyant-travel/quotes", "@voyant-travel/relationships", "@voyant-travel/storefront", "@voyant-travel/trips"];
+export type FrameworkRuntimePackage = (typeof FRAMEWORK_RUNTIME_PACKAGES)[number];
+//# sourceMappingURL=runtime-packages.generated.d.ts.map

package/dist/runtime-packages.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-packages.generated.d.ts","sourceRoot":"","sources":["../src/runtime-packages.generated.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B,4eAkB7B,CAAA;AAEV,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/runtime-packages.generated.js

@@ -0,0 +1,22 @@
+// GENERATED by scripts/generate-framework-bom.mjs — do not edit.
+// The runtime-module set this framework version pins (the BOM membership).
+// Refresh with `node scripts/generate-framework-bom.mjs --emit`.
+export const FRAMEWORK_RUNTIME_PACKAGES = [
+    "@voyant-travel/action-ledger",
+    "@voyant-travel/bookings",
+    "@voyant-travel/catalog",
+    "@voyant-travel/commerce",
+    "@voyant-travel/distribution",
+    "@voyant-travel/finance",
+    "@voyant-travel/flights",
+    "@voyant-travel/identity",
+    "@voyant-travel/inventory",
+    "@voyant-travel/legal",
+    "@voyant-travel/notifications",
+    "@voyant-travel/operations",
+    "@voyant-travel/operator-settings",
+    "@voyant-travel/quotes",
+    "@voyant-travel/relationships",
+    "@voyant-travel/storefront",
+    "@voyant-travel/trips",
+];

package/package.json

@@ -1,64 +1,61 @@
 {
   "name": "@voyant-travel/framework",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Voyant framework BOM — pins the tested runtime-module set so a deployment tracks one framework version and upgrades atomically (no per-package compatibility matrix, no per-package republish/email spam).",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "lint": "biome check src",
-    "clean": "rm -rf dist"
-  },
   "dependencies": {
-    "@voyant-travel/action-ledger": "workspace:*",
-    "@voyant-travel/bookings": "workspace:*",
-    "@voyant-travel/catalog": "workspace:*",
-    "@voyant-travel/commerce": "workspace:*",
-    "@voyant-travel/distribution": "workspace:*",
-    "@voyant-travel/finance": "workspace:*",
-    "@voyant-travel/flights": "workspace:*",
-    "@voyant-travel/identity": "workspace:*",
-    "@voyant-travel/inventory": "workspace:*",
-    "@voyant-travel/legal": "workspace:*",
-    "@voyant-travel/notifications": "workspace:*",
-    "@voyant-travel/operations": "workspace:*",
-    "@voyant-travel/operator-settings": "workspace:*",
-    "@voyant-travel/quotes": "workspace:*",
-    "@voyant-travel/relationships": "workspace:*",
-    "@voyant-travel/storefront": "workspace:*",
-    "@voyant-travel/trips": "workspace:*"
+    "@voyant-travel/action-ledger": "0.105.1",
+    "@voyant-travel/bookings": "0.124.0",
+    "@voyant-travel/catalog": "0.122.0",
+    "@voyant-travel/commerce": "0.6.0",
+    "@voyant-travel/distribution": "0.114.0",
+    "@voyant-travel/finance": "0.124.0",
+    "@voyant-travel/flights": "0.124.0",
+    "@voyant-travel/identity": "0.124.0",
+    "@voyant-travel/inventory": "0.3.4",
+    "@voyant-travel/legal": "0.124.0",
+    "@voyant-travel/notifications": "0.113.0",
+    "@voyant-travel/operations": "0.1.4",
+    "@voyant-travel/operator-settings": "0.2.1",
+    "@voyant-travel/quotes": "0.121.1",
+    "@voyant-travel/relationships": "0.120.1",
+    "@voyant-travel/storefront": "0.125.0",
+    "@voyant-travel/trips": "0.115.0"
   },
   "peerDependencies": {
-    "@voyant-travel/hono": "workspace:^",
-    "hono": "^4.12.10"
+    "hono": "^4.12.10",
+    "@voyant-travel/hono": "^0.112.1"
   },
   "devDependencies": {
-    "@voyant-travel/hono": "workspace:^",
-    "@voyant-travel/voyant-typescript-config": "workspace:^",
     "hono": "^4.12.10",
     "typescript": "^6.0.2",
-    "vitest": "^4.0.0"
+    "vitest": "^4.0.0",
+    "@voyant-travel/hono": "^0.112.1",
+    "@voyant-travel/voyant-typescript-config": "^0.1.0"
   },
   "publishConfig": {
-    "access": "public",
-    "exports": {
-      ".": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js"
-      }
-    }
+    "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/voyantjs/voyant.git",
+    "url": "https://github.com/voyant-travel/voyant.git",
     "directory": "packages/framework"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "biome check src",
+    "clean": "rm -rf dist"
   }
-}
+}