@soulcraft/sdk 3.1.0 → 3.2.0

package/dist/modules/kits/types.d.ts

@@ -2,12 +2,22 @@
  * @module kits/types
  * @description Type definitions for sdk.kits.* — the kit loader and registry module.
  *
- * Kits (`@soulcraft/kits`) are pure configuration packages: `kit.json` manifests
- * and `SKILL.md` prompt files that describe a domain, persona, glossary, and
- * workflow. They contain no TypeScript logic, no server code, and no SDK imports.
+ * Kits are pure configuration packages: `kit.json` manifests, `SKILL.md` prompt
+ * files, template files, and optional station bundles that describe a domain,
+ * persona, glossary, and workflow. They contain no TypeScript logic, no server
+ * code, and no SDK imports.
  *
- * The `KitsModule` provides read-only access to the kit registry: loading a single
- * kit by ID, listing all available kits, and accessing the raw skill registry.
+ * The `KitsModule` provides read-only access to the kit registry. It supports
+ * two backing stores:
+ *
+ * 1. **Registry mode** — when `registryUrl` is provided, kits are fetched from
+ *    the Forge Kit Registry (`forge.soulcraft.com`) over HTTP. Archives (.sck)
+ *    are unpacked to a local disk cache for filesystem access. ETag-based cache
+ *    validation avoids re-downloading unchanged kits.
+ *
+ * 2. **Bundled mode** (legacy) — when no `registryUrl` is provided, kits are
+ *    loaded from the `@soulcraft/kits` npm package via `createRequire()`. This
+ *    is the backwards-compatible fallback used during migration.
  *
  * Kit initialization (populating a workspace's Brainy and VFS from a kit's
  * `starterFiles`) is a product-level concern and lives in each product's
@@ -49,14 +59,94 @@ export interface SoulcraftKitConfig {
     [key: string]: unknown;
 }
 /**
- * Options passed to `createKitsModule()` to override the bundled registry.
- * Primarily useful in tests.
+ * Internal cache entry for a kit fetched from the registry.
+ * Stored in-memory with its ETag for conditional revalidation.
+ */
+export interface CachedKitEntry {
+    /** Parsed kit.json manifest. */
+    manifest: SoulcraftKitConfig;
+    /** ETag from the registry for conditional requests (If-None-Match). */
+    etag: string | null;
+    /** Absolute path to the unpacked kit directory on local disk. */
+    localPath: string;
+    /** Timestamp (ms) when this entry was last fetched or validated. */
+    fetchedAt: number;
+}
+/**
+ * Options for `createKitsModule()`.
+ *
+ * Two modes of operation:
+ *
+ * **Registry mode** — set `registryUrl` to fetch kits from the Forge Kit Registry.
+ * The SDK downloads `.sck` archives, unpacks them to `cachePath`, and serves
+ * filesystem paths from the local cache. ETag-based revalidation avoids
+ * re-downloading unchanged kits.
+ *
+ * **Bundled mode** (legacy) — omit `registryUrl` to load kits from the
+ * `@soulcraft/kits` npm package. This is the backwards-compatible default
+ * used during migration. Set `bundledRegistry` to inject a mock registry
+ * for testing.
+ *
+ * @example Registry mode (production)
+ * ```typescript
+ * const kits = createKitsModule({
+ *   registryUrl: 'https://forge.soulcraft.com',
+ *   cachePath: '/home/app/.soulcraft/kits-cache',
+ * })
+ * ```
+ *
+ * @example Bundled mode (legacy)
+ * ```typescript
+ * const kits = createKitsModule() // uses @soulcraft/kits if installed
+ * ```
+ *
+ * @example Test mode
+ * ```typescript
+ * const kits = createKitsModule({
+ *   bundledRegistry: { 'test-kit': { id: 'test-kit', name: 'Test', ... } }
+ * })
+ * ```
  */
 export interface CreateKitsModuleOptions {
     /**
-     * Override the kit registry loaded from `@soulcraft/kits`.
-     * When provided, the module uses this registry directly instead of requiring
-     * the package. Set to `null` to simulate the package being absent.
+     * Base URL of the Forge Kit Registry (e.g. `'https://forge.soulcraft.com'`).
+     *
+     * When set, the module operates in **registry mode**: kits are fetched over
+     * HTTP, cached locally as unpacked `.sck` archives, and revalidated via ETags.
+     * The `@soulcraft/kits` npm package is not needed.
+     *
+     * When omitted, the module falls back to **bundled mode** using the
+     * `@soulcraft/kits` package.
+     */
+    registryUrl?: string;
+    /**
+     * Absolute path to the local disk cache for unpacked kit archives.
+     *
+     * Defaults to `~/.soulcraft/kits-cache` when `registryUrl` is set.
+     * Each kit is stored at `{cachePath}/{kitId}/` with its full directory tree.
+     *
+     * **Important:** This path must NOT be inside a Brainy data directory to
+     * avoid interfering with entity storage and indexing.
+     */
+    cachePath?: string;
+    /**
+     * Cache freshness duration in milliseconds.
+     *
+     * When a kit is loaded, the SDK checks if the cached copy is younger than
+     * this TTL. If so, it returns the cached manifest without a network request.
+     * When the TTL expires, the SDK sends an `If-None-Match` request — if the
+     * registry returns 304, the cache is refreshed without re-downloading.
+     *
+     * Defaults to `300_000` (5 minutes).
+     */
+    cacheTtlMs?: number;
+    /**
+     * Override the kit registry with a static in-memory map. Used in tests to
+     * avoid both the registry and the `@soulcraft/kits` package.
+     *
+     * Set to `null` to simulate no kits being available.
+     *
+     * **Note:** When `bundledRegistry` is set, `registryUrl` is ignored.
      */
     bundledRegistry?: Record<string, SoulcraftKitConfig> | null;
 }
@@ -64,10 +154,14 @@ export interface CreateKitsModuleOptions {
  * The `sdk.kits.*` namespace — read-only access to the Soulcraft kit registry
  * and template file paths.
  *
- * Backed by the `@soulcraft/kits` package (a peer dependency). If the package
- * is not installed, `load()` returns `null` and `list()` returns an empty array.
- * Path resolver methods return `null` when the package is absent or the directory
- * does not exist.
+ * In **registry mode** (recommended), kits are fetched from the Forge Kit
+ * Registry at `forge.soulcraft.com`, cached locally, and served from disk.
+ * In **bundled mode** (legacy), kits are loaded from the `@soulcraft/kits`
+ * npm package.
+ *
+ * The interface is identical in both modes — callers don't know or care
+ * where kits come from. The `registryUrl` option in `createKitsModule()`
+ * controls the backing store.
  *
  * @example Load a kit and run AI with its persona
  * ```typescript
@@ -83,14 +177,17 @@ export interface CreateKitsModuleOptions {
  * @example Locate kit template files on disk
  * ```typescript
  * const dir = await sdk.kits.resolveFilesPath('blog-series', 'workshop')
- * // → '/path/to/node_modules/@soulcraft/kits/kits/blog-series/workshop/files'
+ * // Registry mode: '~/.soulcraft/kits-cache/blog-series/workshop/files'
+ * // Bundled mode:  '/path/to/node_modules/@soulcraft/kits/kits/blog-series/workshop/files'
  * ```
  */
 export interface KitsModule {
     /**
      * Load a single kit configuration by ID.
      *
-     * Returns `null` if the kit is not found or `@soulcraft/kits` is not installed.
+     * In registry mode, this fetches the manifest from the registry (or returns
+     * a cached copy if within the TTL). In bundled mode, it reads from the
+     * `@soulcraft/kits` package.
      *
      * @param kitId - The kit identifier (e.g. `'wicks-and-whiskers'`).
      * @returns The kit configuration, or `null` if not found.
@@ -105,69 +202,67 @@ export interface KitsModule {
     /**
      * List all available kits from the registry.
      *
-     * Returns an empty array if `@soulcraft/kits` is not installed.
+     * In registry mode, this fetches the full kit listing from the registry.
+     * In bundled mode, it returns all kits from the `@soulcraft/kits` package.
      *
      * @returns All kit configurations as an array.
      *
      * @example
      * ```typescript
      * const kits = await sdk.kits.list()
-     * console.log(kits.map(k => k.name))
+     * console.log(`${kits.length} kits available`)
      * ```
      */
     list(): Promise<SoulcraftKitConfig[]>;
     /**
      * Resolve the absolute path to a kit's product-specific template files directory.
      *
-     * Returns the path to `kits/{kitId}/{product}/files/` inside the installed
-     * `@soulcraft/kits` npm package, or `null` if the directory does not exist
-     * (the kit has no template files for that product, or the package is absent).
+     * In registry mode, the path points into the local cache at
+     * `{cachePath}/{kitId}/{product}/files/`. The kit is downloaded and unpacked
+     * if not already cached. In bundled mode, the path points into the npm package.
      *
-     * This is the single source of truth for kit file paths across all products.
-     * Use it instead of hard-coding `node_modules` paths or maintaining per-product
-     * filesystem layouts.
+     * Returns `null` if the kit is not found or the files directory doesn't exist.
      *
-     * @param kitId - Kit identifier (e.g. `'blog-series'`, `'recipe-manager'`).
+     * @param kitId - Kit identifier (e.g. `'blog-series'`).
      * @param product - Product consuming the files: `'workshop'` or `'venue'`.
-     * @returns Absolute path to the files directory, or `null` if it does not exist.
+     * @returns Absolute path to the files directory, or `null` if not found.
      *
      * @example
      * ```typescript
      * const dir = await sdk.kits.resolveFilesPath('blog-series', 'workshop')
-     * // → '/path/to/node_modules/@soulcraft/kits/kits/blog-series/workshop/files'
+     * // → '~/.soulcraft/kits-cache/blog-series/workshop/files'
      * ```
      */
     resolveFilesPath(kitId: string, product: 'workshop' | 'venue'): Promise<string | null>;
     /**
      * Resolve the absolute path to a kit's skills directory.
      *
-     * Returns the path to `kits/{kitId}/skills/` inside the installed `@soulcraft/kits`
-     * npm package, or `null` if the directory does not exist.
+     * In registry mode, the path points into the local cache at
+     * `{cachePath}/{kitId}/skills/`. In bundled mode, the path points into
+     * the npm package.
      *
      * @param kitId - Kit identifier.
-     * @returns Absolute path to the skills directory, or `null` if it does not exist.
+     * @returns Absolute path to the skills directory, or `null` if not found.
      *
      * @example
      * ```typescript
      * const dir = await sdk.kits.resolveSkillsPath('blog-series')
-     * // → '/path/to/node_modules/@soulcraft/kits/kits/blog-series/skills'
+     * // → '~/.soulcraft/kits-cache/blog-series/skills'
      * ```
      */
     resolveSkillsPath(kitId: string): Promise<string | null>;
     /**
-     * Resolve the absolute path to the root `kits/` directory inside the npm package.
-     *
-     * Useful when enumerating all available kits on the filesystem rather than relying
-     * on the `kitRegistry` in-memory list (e.g. build tooling, validators).
+     * Resolve the absolute path to the root kits cache or package directory.
      *
-     * Returns `null` if `@soulcraft/kits` is not installed.
+     * In registry mode, returns the `cachePath` directory. In bundled mode,
+     * returns the `kits/` directory inside the npm package.
      *
-     * @returns Absolute path to the `kits/` directory, or `null`.
+     * @returns Absolute path to the kits root, or `null` if unavailable.
      *
      * @example
      * ```typescript
      * const root = await sdk.kits.resolveKitsRoot()
-     * // → '/path/to/node_modules/@soulcraft/kits/kits'
+     * // → '~/.soulcraft/kits-cache'
      * ```
      */
     resolveKitsRoot(): Promise<string | null>;

package/dist/modules/kits/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/modules/kits/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAA;IACV,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAA;IACnB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,6BAA6B;IAC7B,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,GAAG,WAAW,CAAA;IAC3D,0CAA0C;IAC1C,MAAM,CAAC,EAAE;QACP,gCAAgC;QAChC,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,+CAA+C;QAC/C,WAAW,CAAC,EAAE,KAAK,CAAC;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KACvD,CAAA;IACD,wDAAwD;IACxD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAMD;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,IAAI,CAAA;CAC5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAA;IAEvD;;;;;;;;;;;;OAYG;IACH,IAAI,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAA;IAErC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAEtF;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAExD;;;;;;;;;;;;;;;OAeG;IACH,eAAe,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CAC1C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/modules/kits/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAA;IACV,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAA;IACnB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,6BAA6B;IAC7B,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,GAAG,WAAW,CAAA;IAC3D,0CAA0C;IAC1C,MAAM,CAAC,EAAE;QACP,gCAAgC;QAChC,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,+CAA+C;QAC/C,WAAW,CAAC,EAAE,KAAK,CAAC;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KACvD,CAAA;IACD,wDAAwD;IACxD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAMD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,uEAAuE;IACvE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAA;IACjB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAA;CAClB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,IAAI,CAAA;CAC5D;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAA;IAEvD;;;;;;;;;;;;;OAaG;IACH,IAAI,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAA;IAErC;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAEtF;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAExD;;;;;;;;;;;;;OAaG;IACH,eAAe,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CAC1C"}

package/dist/modules/kits/types.js

@@ -2,12 +2,22 @@
  * @module kits/types
  * @description Type definitions for sdk.kits.* — the kit loader and registry module.
  *
- * Kits (`@soulcraft/kits`) are pure configuration packages: `kit.json` manifests
- * and `SKILL.md` prompt files that describe a domain, persona, glossary, and
- * workflow. They contain no TypeScript logic, no server code, and no SDK imports.
+ * Kits are pure configuration packages: `kit.json` manifests, `SKILL.md` prompt
+ * files, template files, and optional station bundles that describe a domain,
+ * persona, glossary, and workflow. They contain no TypeScript logic, no server
+ * code, and no SDK imports.
  *
- * The `KitsModule` provides read-only access to the kit registry: loading a single
- * kit by ID, listing all available kits, and accessing the raw skill registry.
+ * The `KitsModule` provides read-only access to the kit registry. It supports
+ * two backing stores:
+ *
+ * 1. **Registry mode** — when `registryUrl` is provided, kits are fetched from
+ *    the Forge Kit Registry (`forge.soulcraft.com`) over HTTP. Archives (.sck)
+ *    are unpacked to a local disk cache for filesystem access. ETag-based cache
+ *    validation avoids re-downloading unchanged kits.
+ *
+ * 2. **Bundled mode** (legacy) — when no `registryUrl` is provided, kits are
+ *    loaded from the `@soulcraft/kits` npm package via `createRequire()`. This
+ *    is the backwards-compatible fallback used during migration.
  *
  * Kit initialization (populating a workspace's Brainy and VFS from a kit's
  * `starterFiles`) is a product-level concern and lives in each product's

package/dist/modules/kits/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/modules/kits/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/modules/kits/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG"}

package/dist/venue/index.d.ts

@@ -1,20 +1,24 @@
 /**
  * @module @soulcraft/sdk/venue
- * @description Public entry point for Venue platform service types.
+ * @description Type-only entry point for Venue platform service interfaces.
  *
  * Re-exports all typed service interfaces from `./services.ts`. Kit authors
- * and station developers import from this path:
+ * and station developers import types from this path:
  *
  * ```ts
  * import type { VenueServicesContext, VenueBookingsService } from '@soulcraft/sdk/venue';
  * ```
  *
- * These types describe the client-side contract. The same types are consumed by:
- * - `service-proxies.ts` — HTTP proxy implementation (browser)
- * - `sdk/venue/*.ts` — handler implementation (server)
+ * For the runtime proxy factory, import from `@soulcraft/sdk/client`:
  *
- * Transport is transparent: the interface is the same whether the proxy uses
- * HTTP/JSON, WebSocket/MessagePack, or direct function calls (local transport).
+ * ```ts
+ * import { createVenueProxy } from '@soulcraft/sdk/client';
+ * ```
+ *
+ * This follows the SDK's established split:
+ * - `@soulcraft/sdk` and `@soulcraft/sdk/venue` — types only, environment-agnostic
+ * - `@soulcraft/sdk/client` — browser runtime (transports, proxy factories)
+ * - `@soulcraft/sdk/server` — server runtime (RPC handlers, instance pool)
  */
 export type { VenueServicesContext, DashboardData, VenueDashboardService, VenueSettingsService, VenueThemeService, VenueStationOrderService, BookingSummary, VenueBookingsService, VenueCheckinService, VenueScheduleService, VenueStaffService, VenueExperiencesService, VenueWaiversService, VenuePosService, VenueKittensService, VenueAdoptionsService, VenueMemoriesService, VenueTransactionsService, VenueInventoryService, VenueProductsService, VenueGiftCardsService, VenueLoyaltyService, VenueSubscriptionsService, VenueCustomersService, OrderStatus, OrderFilters, OrderSummary, OrderDetail, VenueOrdersService, VenueCartService, FulfillmentStatus, FulfillmentFilters, VenueFulfillmentService, DiscountType, VenueDiscountsService, VenueContentService, VenueBlogService, VenuePartnersService, CmsPageMeta, VenuePagesService, BlueprintField, BlueprintSection, BlueprintDefinition, VenueBlueprintsService, BlockTypeDefinition, VenueBlocksService, MediaItem, MediaFilters, VenueMediaService, VenueAnalyticsService, VenueAuditService, VenueFinancialsService, VenueDomainsService, VenueWebhooksService, VenueScheduledJobsService, VenueDeploymentsService, VenueFranchiseService, VenueKitsService, VenueBillingService, EntityFilters, VenueEntitiesService, } from './services.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/venue/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/venue/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,YAAY,EAEX,oBAAoB,EAGpB,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,EAGxB,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EAGpB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,EACvB,YAAY,EACZ,qBAAqB,EAGrB,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,iBAAiB,EAGjB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EAGnB,aAAa,EACb,oBAAoB,GACpB,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/venue/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,YAAY,EAEX,oBAAoB,EAGpB,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,EAGxB,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EAGpB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,EACvB,YAAY,EACZ,qBAAqB,EAGrB,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,iBAAiB,EAGjB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EAGnB,aAAa,EACb,oBAAoB,GACpB,MAAM,eAAe,CAAC"}

package/dist/venue/index.js

@@ -1,20 +1,24 @@
 /**
  * @module @soulcraft/sdk/venue
- * @description Public entry point for Venue platform service types.
+ * @description Type-only entry point for Venue platform service interfaces.
  *
  * Re-exports all typed service interfaces from `./services.ts`. Kit authors
- * and station developers import from this path:
+ * and station developers import types from this path:
  *
  * ```ts
  * import type { VenueServicesContext, VenueBookingsService } from '@soulcraft/sdk/venue';
  * ```
  *
- * These types describe the client-side contract. The same types are consumed by:
- * - `service-proxies.ts` — HTTP proxy implementation (browser)
- * - `sdk/venue/*.ts` — handler implementation (server)
+ * For the runtime proxy factory, import from `@soulcraft/sdk/client`:
  *
- * Transport is transparent: the interface is the same whether the proxy uses
- * HTTP/JSON, WebSocket/MessagePack, or direct function calls (local transport).
+ * ```ts
+ * import { createVenueProxy } from '@soulcraft/sdk/client';
+ * ```
+ *
+ * This follows the SDK's established split:
+ * - `@soulcraft/sdk` and `@soulcraft/sdk/venue` — types only, environment-agnostic
+ * - `@soulcraft/sdk/client` — browser runtime (transports, proxy factories)
+ * - `@soulcraft/sdk/server` — server runtime (RPC handlers, instance pool)
  */
 export {};
 //# sourceMappingURL=index.js.map

package/dist/venue/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/venue/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/venue/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/venue/proxy.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module @soulcraft/sdk/venue/proxy
+ * @description Transport-agnostic proxy factory for the Venue service surface.
+ *
+ * Creates a fully typed {@link VenueServicesContext} backed by any
+ * {@link NamespaceTransport}. Consumers call typed methods like
+ * `services.bookings.list('2026-03-20')` — the proxy serializes each call as
+ * `transport.callNs('venue', 'listBookings', ['2026-03-20'])`.
+ *
+ * This design makes transport selection a deployment decision, not a code decision:
+ *
+ * ```ts
+ * // HTTP (default for browser stations)
+ * const services = createVenueProxy(httpTransport);
+ *
+ * // WebSocket (default for real-time stations)
+ * const services = createVenueProxy(wsTransport);
+ *
+ * // Local (same process — zero overhead)
+ * const services = createVenueProxy(localTransport);
+ * ```
+ *
+ * Station components never know or care which transport is active. The interface
+ * is identical across all three.
+ *
+ * @see {@link VenueServicesContext} — the typed interface this factory implements
+ * @see {@link NamespaceTransport} — the transport abstraction from `@soulcraft/sdk/client`
+ */
+import type { NamespaceTransport } from '../client/namespace-proxy.js';
+import type { VenueServicesContext } from './services.js';
+/**
+ * Creates a fully typed {@link VenueServicesContext} backed by a {@link NamespaceTransport}.
+ *
+ * Every method on the returned object delegates to `transport.callNs('venue', ...)`.
+ * The transport handles serialization, authentication, and error surfacing.
+ *
+ * @param transport - Any {@link NamespaceTransport} implementation (HTTP, WS, local).
+ * @returns A complete {@link VenueServicesContext} proxy.
+ *
+ * @example
+ * ```ts
+ * import { createVenueProxy } from '@soulcraft/sdk/venue';
+ * import { HttpNamespaceTransport } from '@soulcraft/sdk/client';
+ *
+ * const transport = new HttpNamespaceTransport({ baseUrl: 'https://myshop.venue.soulcraft.com' });
+ * const services = createVenueProxy(transport);
+ *
+ * // Full autocomplete and type safety:
+ * const { bookings } = await services.bookings.list('2026-03-20');
+ * const stats = await services.dashboard.getStats();
+ * ```
+ */
+export declare function createVenueProxy(transport: NamespaceTransport): VenueServicesContext;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/venue/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/venue/proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAiB1D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,kBAAkB,GAAG,oBAAoB,CA6TpF"}