@voltro/plugin-inventory 0.0.0-stage → 0.87.0

package/dist/index.d.ts

@@ -0,0 +1,576 @@
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { PreparedSqlMutation } from '@voltro/database/sql';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+/** Admit actual child receipt or retained craft evidence without rerunning a wallet callback. */
+export declare const captureCraftPayment: (input: unknown, recipe: Recipe, batches: number) => CraftPaymentReceipt | null;
+
+/** Admit retained intent without calling historical custom policies. */
+export declare const captureCraftPlan: (original: unknown, input: CraftInput) => CraftPlan;
+
+declare interface CatalogImport extends CatalogScope {
+    readonly revision: string;
+    readonly items: readonly CatalogItem[];
+}
+
+/** Serializable content uses a declared item's version, never a stored Schema object. */
+export declare interface CatalogItem {
+    readonly id: string;
+    readonly schemaVersion: number;
+    readonly kind: ItemKind;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+    readonly attributes: JsonValue;
+    readonly instanceDefaults: JsonValue;
+}
+
+export declare interface CatalogScope {
+    readonly tenantId: string;
+    readonly channel: string;
+    readonly locale: string;
+}
+
+export declare interface CatalogSnapshot {
+    readonly revision: string;
+    readonly items: readonly CatalogItem[];
+}
+
+export declare class CatalogSource extends CatalogSource_base {
+}
+
+declare const CatalogSource_base: Context.ServiceClass<CatalogSource, "@voltro/CatalogSource", CatalogSourceService>;
+
+/** Read only. Call at join/workflow boundaries, never from a room tick. */
+export declare interface CatalogSourceService {
+    readonly read: (scope: CatalogScope) => Effect.Effect<CatalogSnapshot, InventoryError>;
+}
+
+export declare interface CraftEconomyParticipant {
+    readonly prepareTransfer: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly requestId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly from: {
+            readonly kind: 'wallet';
+            readonly ownerKind: 'player' | 'guild';
+            readonly ownerId: string;
+        };
+        readonly to: {
+            readonly kind: 'system';
+            readonly id: string;
+        };
+        readonly reason: string;
+        readonly ref: {
+            readonly kind: string;
+            readonly id: string;
+        };
+    }) => Effect.Effect<PreparedSqlMutation<CraftPaymentReceipt>, {
+        readonly code: string;
+    }>;
+}
+
+export declare interface CraftingOptions {
+    readonly recipes: readonly (RecipeDefinition | Recipe)[];
+    readonly craftResolver?: CraftResolver | undefined;
+    readonly version?: string | undefined;
+    readonly service?: CraftingService | undefined;
+    readonly economy?: CraftEconomyParticipant | undefined;
+    readonly systemAccount?: string | undefined;
+}
+
+export declare class CraftingPort extends CraftingPort_base {
+}
+
+declare const CraftingPort_base: Context.ServiceClass<CraftingPort, "@voltro/CraftingPort", CraftingService>;
+
+/** Small independent seam; InventoryPort retains its eight-method surface. */
+export declare interface CraftingService {
+    readonly craft: (subject: Subject, input: CraftRequest) => Effect.Effect<InventoryReceipt, InventoryError>;
+    readonly recipes: (subject: Subject) => Effect.Effect<readonly Recipe[], InventoryError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, InventoryError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, InventoryError>;
+}
+
+export declare interface CraftInput {
+    readonly recipe: Recipe;
+    readonly batches: number;
+    readonly at: number;
+    readonly available: readonly InventoryInstance[];
+    readonly excludedIds: readonly string[];
+}
+
+export declare interface CraftPaymentReceipt {
+    readonly txId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly at: number;
+}
+
+export declare interface CraftPlan {
+    readonly consume: readonly {
+        readonly instanceId: string;
+        readonly qty: number;
+    }[];
+    readonly outputs: readonly RecipeOutput[];
+}
+
+export declare interface CraftRequest {
+    readonly tenantId: string;
+    readonly owner: InventoryOwner;
+    readonly recipeId: string;
+    readonly requestId: string;
+    readonly batches?: number;
+}
+
+export declare type CraftResolver = (input: CraftInput) => CraftPlan;
+
+/** SQL source owns immutable snapshots and a tenant-wide identity/version registry. */
+declare const dataStoreCatalog: (store: DataStore, input: SqlCatalogOptions) => Readonly<{
+    read: (scope: CatalogScope) => Effect.Effect<CatalogSnapshot, InventoryError>;
+    importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect<CatalogSnapshot, InventoryError>;
+}>;
+
+/** Deterministic oldest acquisitions first; equipped, locked and expired items never enter a recipe. */
+export declare const defaultCraftResolver: CraftResolver;
+
+export declare const defaultExpiryPolicy: ExpiryPolicy;
+
+export declare const defaultStackPolicy: StackPolicy;
+
+export declare const defineItem: (input: ItemDefinition) => ItemContract;
+
+/** Immediate recipe; currency cost requires an installed exact-store prepared participant. Duration/prerequisites refuse. */
+export declare const defineRecipe: (input: RecipeDefinition) => Recipe;
+
+declare interface ExpiryInput {
+    readonly item: CatalogItem;
+    readonly acquiredAt: number;
+}
+
+export declare type ExpiryPolicy = (input: ExpiryInput) => number | null;
+
+declare interface InventoryAudit {
+    readonly instances: number;
+    readonly ledgerRows: number;
+    readonly matches: boolean;
+}
+
+export declare interface InventoryConsume {
+    readonly tenantId: string;
+    readonly owner: InventoryOwner;
+    readonly requestId: string;
+    readonly instanceId: string;
+    readonly qty: number;
+    readonly reason: string;
+    readonly ref: InventoryRef;
+}
+
+export declare interface InventoryEquip {
+    readonly slotSet: string;
+    readonly slot: string;
+    readonly instanceId: string | null;
+    readonly requestId: string;
+}
+
+/** Public errors carry codes, never subjects, catalog values or provider causes. */
+export declare class InventoryError extends InventoryError_base {
+}
+
+declare const InventoryError_base: Schema.Class<InventoryError, Schema.TaggedStruct<"InventoryError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_item", "invalid_attributes", "conflict", "forbidden", "not_found", "unavailable", "limit_exceeded", "erased", "insufficient_items", "insufficient_funds", "payment_refused", "locked", "expired", "invalid_slot"]>;
+}>, YieldableError>;
+
+export declare interface InventoryExpire {
+    readonly tenantId: string;
+    readonly owner: InventoryOwner;
+    readonly requestId: string;
+    readonly until: number;
+}
+
+export declare interface InventoryGrant {
+    readonly tenantId: string;
+    readonly owner: InventoryOwner;
+    readonly requestId: string;
+    readonly itemId: string;
+    readonly qty: number;
+    readonly attributes?: JsonValue;
+    readonly reason: string;
+    readonly ref: InventoryRef;
+}
+
+export declare interface InventoryInstance {
+    readonly id: string;
+    readonly itemId: string;
+    readonly schemaVersion: number;
+    readonly qty: number;
+    readonly attributes: JsonValue;
+    readonly acquiredAt: number;
+    readonly expiresAt: number | null;
+    readonly locked: boolean;
+    readonly source: string;
+}
+
+export declare interface InventoryLoadout {
+    readonly slotSet: string;
+    readonly slot: string;
+    readonly instanceId: string;
+}
+
+export declare interface InventoryOwner {
+    readonly ownerKind: 'player' | 'guild';
+    readonly ownerId: string;
+}
+
+export declare interface InventoryPlugin extends VoltroPlugin {
+    readonly inventory: {
+        readonly service: () => InventoryService;
+        readonly crafting: () => CraftingService;
+        readonly importCatalog: (subject: Subject, input: CatalogImport) => ReturnType<ReturnType<typeof dataStoreCatalog>['importSnapshot']>;
+        readonly prepareReservationTransfer: InventorySqlService['prepareReservationTransfer'];
+        readonly prepareReserveTransfer: InventorySqlService['prepareReserveTransfer'];
+        readonly prepareReserve: InventorySqlService['prepareReserve'];
+        readonly prepareRelease: InventorySqlService['prepareRelease'];
+        readonly reservation: InventorySqlService['reservation'];
+        readonly reservationEvidence: InventorySqlService['reservationEvidence'];
+        readonly prepareGrant: InventorySqlService['prepareGrant'];
+        readonly prepareCraft: InventorySqlService['prepareCraft'];
+        readonly auditInventory: InventorySqlService['auditInventory'];
+        readonly rebuildInventory: InventorySqlService['rebuildInventory'];
+    };
+}
+
+export declare const inventoryPlugin: (input: InventoryPluginOptions) => InventoryPlugin;
+
+export declare interface InventoryPluginOptions extends Omit<InventoryStoreOptions, 'catalogSource' | 'channel' | 'locale'> {
+    readonly catalogSource?: CatalogSourceService;
+    readonly channel?: string;
+    readonly locale?: string;
+    readonly maxCatalogItems?: number;
+    readonly maxCatalogVersions?: number;
+    /** A replacement implements the same authority, receipt and privacy contract. */
+    readonly service?: InventoryService;
+}
+
+export declare class InventoryPort extends InventoryPort_base {
+}
+
+declare const InventoryPort_base: Context.ServiceClass<InventoryPort, "@voltro/InventoryPort", InventoryService>;
+
+export declare interface InventoryReceipt {
+    readonly operationId: string;
+    readonly kind: 'grant' | 'consume' | 'equip' | 'expire' | 'craft' | 'reserve' | 'release' | 'transfer-out' | 'transfer-in';
+    readonly changes: readonly {
+        readonly instanceId: string;
+        readonly delta: number;
+    }[];
+    readonly at: number;
+}
+
+declare interface InventoryRef {
+    readonly kind: string;
+    readonly id: string;
+}
+
+declare interface InventoryReleaseInput {
+    readonly tenantId: string;
+    readonly owner: InventoryOwner;
+    readonly reservationId: string;
+}
+
+/** Original custody proof, separate from current availability. A redacted peer
+ * has no serialized receipt; its retained movement conservation is still checked. */
+declare interface InventoryReservationEvidence {
+    readonly reservationId: string;
+    readonly state: InventoryReservationView['state'];
+    readonly items: InventoryReservationView['items'];
+    readonly reserve: InventoryReceipt | null;
+    readonly release: InventoryReceipt | null;
+    readonly transfer: {
+        readonly from: InventoryReceipt;
+        readonly to: InventoryReceipt | null;
+    } | null;
+}
+
+declare interface InventoryReservationTransferInput {
+    readonly tenantId: string;
+    readonly from: InventoryOwner;
+    readonly to: InventoryOwner;
+    readonly reservationId: string;
+}
+
+declare interface InventoryReservationTransferReceipt {
+    readonly reservationId: string;
+    readonly from: InventoryReceipt;
+    readonly to: InventoryReceipt;
+}
+
+declare interface InventoryReservationView {
+    readonly reservationId: string;
+    readonly state: 'not-observed' | 'reserved' | 'released' | 'transferred';
+    readonly items: readonly {
+        readonly qty: number;
+        readonly instance: InventoryInstance;
+    }[];
+}
+
+declare interface InventoryReservedTransferReceipt {
+    readonly reserve: InventoryReceipt;
+    readonly transfer: InventoryReservationTransferReceipt;
+}
+
+/** Trusted server participant input. Selecting quantities never proves ownership. */
+declare interface InventoryReserveInput {
+    readonly tenantId: string;
+    readonly owner: InventoryOwner;
+    readonly reservationId: string;
+    readonly items: readonly {
+        readonly instanceId: string;
+        readonly qty: number;
+    }[];
+}
+
+declare interface InventoryReserveTransferInput extends InventoryReservationTransferInput {
+    readonly items: readonly {
+        readonly instanceId: string;
+        readonly qty: number;
+    }[];
+}
+
+/** Installed routes and trusted callers use this same replaceable service. */
+export declare interface InventoryService {
+    readonly grant: (subject: Subject, input: InventoryGrant) => Effect.Effect<InventoryReceipt, InventoryError>;
+    readonly consume: (subject: Subject, input: InventoryConsume) => Effect.Effect<InventoryReceipt, InventoryError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly InventoryInstance[], InventoryError>;
+    readonly loadout: (subject: Subject, slotSet: string) => Effect.Effect<readonly InventoryLoadout[], InventoryError>;
+    readonly equip: (subject: Subject, input: InventoryEquip) => Effect.Effect<InventoryReceipt, InventoryError>;
+    readonly expire: (subject: Subject, input: InventoryExpire) => Effect.Effect<InventoryReceipt, InventoryError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, InventoryError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, InventoryError>;
+}
+
+declare interface InventorySqlService extends InventoryService {
+    readonly prepareConsume: (subject: Subject, input: Parameters<InventoryService['consume']>[1]) => Effect.Effect<PreparedSqlMutation<InventoryReceipt>, InventoryError>;
+    readonly prepareReserveTransfer: (subject: Subject, input: InventoryReserveTransferInput) => Effect.Effect<PreparedSqlMutation<InventoryReservedTransferReceipt>, InventoryError>;
+    readonly prepareReservationTransfer: (subject: Subject, input: InventoryReservationTransferInput) => Effect.Effect<PreparedSqlMutation<InventoryReservationTransferReceipt>, InventoryError>;
+    readonly prepareReserve: (subject: Subject, input: InventoryReserveInput) => Effect.Effect<PreparedSqlMutation<InventoryReceipt>, InventoryError>;
+    readonly prepareRelease: (subject: Subject, input: InventoryReleaseInput) => Effect.Effect<PreparedSqlMutation<InventoryReceipt>, InventoryError>;
+    readonly reservation: (subject: Subject, input: InventoryReleaseInput) => Effect.Effect<InventoryReservationView, InventoryError>;
+    readonly reservationEvidence: (subject: Subject, input: InventoryReleaseInput) => Effect.Effect<InventoryReservationEvidence, InventoryError>;
+    readonly prepareGrant: (subject: Subject, input: InventoryGrant) => Effect.Effect<PreparedSqlMutation<InventoryReceipt>, InventoryError>;
+    readonly prepareCraft: (subject: Subject, input: CraftRequest) => Effect.Effect<PreparedSqlMutation<InventoryReceipt>, InventoryError>;
+    readonly craft: (subject: Subject, input: CraftRequest) => Effect.Effect<InventoryReceipt, InventoryError>;
+    readonly auditInventory: (subject: Subject, tenantId: string, owner: InventoryOwner) => Effect.Effect<InventoryAudit, InventoryError>;
+    readonly rebuildInventory: (subject: Subject, tenantId: string, owner: InventoryOwner) => Effect.Effect<InventoryAudit, InventoryError>;
+}
+
+declare interface InventoryStoreOptions {
+    readonly items: readonly ItemDefinition[];
+    readonly catalogSource: CatalogSourceService;
+    readonly channel: string;
+    readonly locale: string;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly slotSets?: Readonly<Record<string, readonly string[]>> | undefined;
+    readonly maxInstances?: number | undefined;
+    readonly maxLedgerRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly stackPolicy?: StackPolicy | undefined;
+    readonly expiryPolicy?: ExpiryPolicy | undefined;
+    readonly crafting?: CraftingOptions | undefined;
+}
+
+/** System21 manifest: strategy slots, ports and events this system declares. */
+export declare const inventorySystemContract: Readonly<{
+    slots: {
+        stackPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        expiryPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        craftResolver: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        inventory: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        crafting: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        catalogSource: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+declare const ITEM_KINDS: readonly ["consumable", "equipment", "cosmetic", "currencyBundle", "key", "mod"];
+
+export declare const itemContent: (contract: ItemContract, attributes: unknown, instanceDefaults: unknown) => CatalogItem;
+
+export declare interface ItemContract extends Omit<ItemDefinition, 'schemaVersion' | 'equipSlot' | 'expiresAfter' | 'display'> {
+    readonly schemaVersion: number;
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+}
+
+export declare interface ItemDefinition {
+    readonly id: string;
+    readonly kind: ItemKind;
+    readonly schemaVersion?: number;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly attributes: Schema.Top;
+    readonly instanceAttributes: Schema.Top;
+    readonly equipSlot?: string | null;
+    /** Milliseconds; resolved on grant, never by a tick. */
+    readonly expiresAfter?: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon?: string | null;
+    };
+}
+
+export declare type ItemKind = typeof ITEM_KINDS[number];
+
+declare type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+
+export declare interface Recipe {
+    readonly id: string;
+    readonly version: number;
+    readonly inputs: readonly RecipeIngredient[];
+    readonly outputs: readonly RecipeOutput[];
+    readonly maxBatches: number;
+    readonly cost: RecipeCurrencyCost | null;
+    readonly timeMs: 0;
+    readonly requires: null;
+}
+
+export declare interface RecipeCurrencyCost {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+export declare interface RecipeDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly inputs: readonly RecipeIngredient[];
+    readonly outputs: readonly RecipeOutput[];
+    readonly maxBatches?: number;
+    readonly cost?: RecipeCurrencyCost | null;
+    readonly timeMs?: 0;
+    readonly requires?: null;
+}
+
+export declare interface RecipeIngredient {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+export declare interface RecipeOutput extends RecipeIngredient {
+    readonly attributes?: JsonValue;
+}
+
+export declare const resolveCraftingOptions: (input: CraftingOptions) => Readonly<{
+    economy: Readonly<{
+        prepareTransfer: (subject: Subject, input: {
+            readonly tenantId: string;
+            readonly requestId: string;
+            readonly currency: string;
+            readonly amount: string;
+            readonly from: {
+                readonly kind: "wallet";
+                readonly ownerKind: "player" | "guild";
+                readonly ownerId: string;
+            };
+            readonly to: {
+                readonly kind: "system";
+                readonly id: string;
+            };
+            readonly reason: string;
+            readonly ref: {
+                readonly kind: string;
+                readonly id: string;
+            };
+        }) => Effect.Effect<PreparedSqlMutation<CraftPaymentReceipt>, {
+            readonly code: string;
+        }>;
+    }> | undefined;
+    systemAccount: string | undefined;
+    recipes: readonly Recipe[];
+    craftResolver: CraftResolver;
+    version: string;
+    service: CraftingService | undefined;
+}>;
+
+/** Custom selection may choose instances and valid output attributes, never amounts or additional value. */
+export declare const resolveCraftPlan: (input: CraftInput, resolver?: CraftResolver) => CraftPlan;
+
+export declare const resolveExpiry: (input: ExpiryInput, policy?: ExpiryPolicy) => number | null;
+
+/** A custom policy cannot mint, discard, duplicate or exceed a stack's cap. */
+export declare const resolveStack: (input: StackInput, policy?: StackPolicy) => StackPlan;
+
+declare interface SqlCatalogOptions {
+    readonly items: readonly ItemDefinition[];
+    readonly allowedServices?: readonly string[];
+    readonly maxCatalogItems?: number;
+    readonly maxCatalogVersions?: number;
+    readonly now?: () => number;
+}
+
+declare interface StackInput {
+    readonly item: CatalogItem;
+    readonly quantity: number;
+    readonly available: readonly {
+        readonly id: string;
+        readonly quantity: number;
+    }[];
+}
+
+declare interface StackPlan {
+    readonly existing: readonly {
+        readonly id: string;
+        readonly add: number;
+    }[];
+    readonly create: readonly number[];
+}
+
+export declare type StackPolicy = (input: StackInput) => StackPlan;
+
+export { }

package/dist/index.js

@@ -0,0 +1,8 @@
+import { InventoryError as e } from "./errors.js";
+import { CraftingPort as t, captureCraftPayment as n, captureCraftPlan as r, defaultCraftResolver as i, defineRecipe as a, resolveCraftPlan as o, resolveCraftingOptions as s } from "./crafting.js";
+import { defineItem as c, itemContent as l } from "./item.js";
+import { CatalogSource as u } from "./catalog.js";
+import { defaultExpiryPolicy as d, defaultStackPolicy as f, resolveExpiry as p, resolveStack as m } from "./strategies.js";
+import { InventoryPort as h } from "./port.js";
+import { inventoryPlugin as g, inventorySystemContract as _ } from "./plugin.js";
+export { u as CatalogSource, t as CraftingPort, e as InventoryError, h as InventoryPort, n as captureCraftPayment, r as captureCraftPlan, i as defaultCraftResolver, d as defaultExpiryPolicy, f as defaultStackPolicy, c as defineItem, a as defineRecipe, g as inventoryPlugin, _ as inventorySystemContract, l as itemContent, o as resolveCraftPlan, s as resolveCraftingOptions, p as resolveExpiry, m as resolveStack };

package/dist/inventoryPort.fixture.js

@@ -0,0 +1,66 @@
+import { inventoryError as e } from "./errors.js";
+import { identifier as t, list as n, object as r } from "./capture.js";
+import { defineRecipe as i } from "./crafting.js";
+import { captureCatalogItem as a, captureItemContracts as o } from "./item.js";
+import { inventoryPlugin as s } from "./plugin.js";
+import { Effect as c, Layer as l } from "effect";
+import { systemSubject as u } from "@voltro/protocol";
+import { ensureTableRegistered as d } from "@voltro/database";
+import { InMemoryDataStore as f } from "@voltro/runtime";
+//#region src/inventoryPort.fixture.ts
+function p(p) {
+	let m = r(p, [
+		"tenantId",
+		"items",
+		"content",
+		"recipes",
+		"slotSets",
+		"now"
+	]), h = t(m.tenantId), g = o(m.items), _ = Object.freeze(n(m.content, 1e4).map((e) => a(e, g)));
+	if (new Set(_.map((e) => JSON.stringify([e.id, e.schemaVersion]))).size !== _.length) throw e("invalid_input");
+	let v = Object.freeze(n(m.recipes ?? [], 256).map((e) => i(e)));
+	if (m.recipes !== void 0 && !v.length || v.some((e) => e.cost !== null)) throw e("invalid_input");
+	let y = Object.create(null);
+	for (let [i, a] of Object.entries(r(m.slotSets ?? {}))) {
+		t(i);
+		let r = Object.freeze(n(a, 64).map(t));
+		if (new Set(r).size !== r.length) throw e("invalid_input");
+		y[i] = r;
+	}
+	Object.freeze(y);
+	let b = m.now ?? Date.now;
+	if (typeof b != "function") throw e("invalid_input");
+	let x = {
+		app: {
+			name: "inventory-port-fixture",
+			type: "api",
+			voltroVersion: "0.83.1"
+		},
+		config: {},
+		env: {},
+		logger: {
+			info() {},
+			warn() {},
+			error() {},
+			debug() {}
+		}
+	}, S = c.acquireRelease(c.sync(() => s({
+		items: g,
+		slotSets: y,
+		now: b,
+		...v.length ? { crafting: { recipes: v } } : {}
+	})), (e) => c.suspend(() => e.onDeactivate(x))).pipe(c.tap((e) => c.gen(function* () {
+		e.extendSchema.tables.forEach((e) => d(e));
+		let t = new f();
+		yield* c.promise(() => Promise.resolve(e.bindDataStore(t))), yield* e.inventory.importCatalog(u("inventory.port.fixture"), {
+			tenantId: h,
+			channel: "live",
+			locale: "en",
+			revision: "fixture.r1",
+			items: _
+		});
+	}).pipe(c.orDie))), C = l.effectContext(S.pipe(c.flatMap((e) => l.build(e.services))));
+	return Object.freeze({ layer: C });
+}
+//#endregion
+export { p as inventoryPortFixture };