@sharpee/world-model 0.9.66-beta → 0.9.69-beta

package/capabilities/capability-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-helpers.js","sourceRoot":"","sources":["../../../../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/capability-helpers.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAyBH,0DAWC;AAgBD,sCAEC;AAQD,sDAWC;AAkBD,gDAYC;AAQD,4CAKC;AA/GD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,uBAAuB,CACrC,MAAgB,EAChB,QAAgB;IAEhB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QAC3C,MAAM,UAAU,GAAG,KAAK,CAAC,WAAgC,CAAC;QAC1D,IAAI,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAChD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,aAAa,CAAC,MAAgB,EAAE,QAAgB;IAC9D,OAAO,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,SAAS,CAAC;AACjE,CAAC;AAED;;;;;GAKG;AACH,SAAgB,qBAAqB,CAAC,MAAgB;IACpD,MAAM,YAAY,GAAa,EAAE,CAAC;IAElC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QAC3C,MAAM,UAAU,GAAG,KAAK,CAAC,WAAgC,CAAC;QAC1D,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;YAC5B,YAAY,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,kBAAkB,CAChC,KAAa,EACb,QAAgB,EAChB,SAAqC;IAErC,MAAM,UAAU,GAAG,KAAK,CAAC,WAAgC,CAAC;IAC1D,MAAM,SAAS,GAAG,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC;IAEvE,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,SAAS,IAAI,KAAK,YAAY,SAAS,CAAC;IACjD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,MAAgB;IAC/C,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;QACvD,MAAM,UAAU,GAAG,KAAK,CAAC,WAAgC,CAAC;QAC1D,OAAO,UAAU,CAAC,YAAY,IAAI,UAAU,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;AACL,CAAC"}

package/capabilities/capability-registry.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Capability Registry (ADR-090)
+ *
+ * Registry for trait-behavior bindings. Stories register behaviors
+ * for their traits, and the dispatch system looks them up at runtime.
+ */
+import { ITrait } from '../traits/trait';
+import { CapabilityBehavior } from './capability-behavior';
+import { CapabilityResolution, CapabilityMode } from './capability-defaults';
+/**
+ * Options for registering a capability behavior.
+ */
+export interface BehaviorRegistrationOptions<T extends ITrait = ITrait> {
+    /** Priority for resolution (higher = checked first). Default: 0 */
+    priority?: number;
+    /** Override global resolution strategy for this binding */
+    resolution?: CapabilityResolution;
+    /** Override global mode for this binding */
+    mode?: CapabilityMode;
+    /** Optional runtime validation */
+    validateBinding?: (trait: T) => boolean;
+}
+/**
+ * Binding between a trait type, capability, and behavior.
+ */
+export interface TraitBehaviorBinding<T extends ITrait = ITrait> {
+    /** Trait type identifier */
+    traitType: string;
+    /** Action ID (capability) this binding handles */
+    capability: string;
+    /** The behavior that handles this trait+capability */
+    behavior: CapabilityBehavior;
+    /** Priority for resolution (higher = checked first) */
+    priority: number;
+    /** Override resolution strategy (undefined = use global default) */
+    resolution?: CapabilityResolution;
+    /** Override mode (undefined = use global default) */
+    mode?: CapabilityMode;
+    /** Optional runtime validation */
+    validateBinding?: (trait: T) => boolean;
+}
+/**
+ * Register a behavior for a trait+capability combination.
+ *
+ * Stories call this to register their behaviors during initialization.
+ * Each trait+capability pair can only have one behavior registered.
+ *
+ * @param traitType - The trait type identifier (e.g., 'dungeo.trait.basket_elevator')
+ * @param capability - The action ID (e.g., 'if.action.lowering')
+ * @param behavior - The behavior implementation
+ * @param options - Optional configuration (priority, resolution override, mode override)
+ *
+ * @example
+ * ```typescript
+ * // Basic registration (uses global defaults)
+ * registerCapabilityBehavior(
+ *   BasketElevatorTrait.type,
+ *   'if.action.lowering',
+ *   BasketLoweringBehavior
+ * );
+ *
+ * // With priority and overrides
+ * registerCapabilityBehavior(
+ *   TrollAxeTrait.type,
+ *   'if.action.taking',
+ *   TrollAxeTakingBehavior,
+ *   { priority: 100, resolution: 'any-blocks' }
+ * );
+ * ```
+ */
+export declare function registerCapabilityBehavior<T extends ITrait>(traitType: string, capability: string, behavior: CapabilityBehavior, options?: BehaviorRegistrationOptions<T>): void;
+/**
+ * Get behavior for a trait instance and capability.
+ *
+ * Called by capability-dispatch actions to find the right behavior.
+ *
+ * @param trait - The trait instance
+ * @param capability - The action ID
+ * @returns The behavior, or undefined if not registered
+ */
+export declare function getBehaviorForCapability(trait: ITrait, capability: string): CapabilityBehavior | undefined;
+/**
+ * Get the full binding for a trait instance and capability.
+ *
+ * Includes priority and configuration overrides. Used by dispatch helper
+ * for resolution logic.
+ *
+ * @param trait - The trait instance
+ * @param capability - The action ID
+ * @returns The binding, or undefined if not registered
+ */
+export declare function getBehaviorBinding(trait: ITrait, capability: string): TraitBehaviorBinding | undefined;
+/**
+ * Check if a behavior is registered for a trait+capability.
+ *
+ * @param traitType - The trait type identifier
+ * @param capability - The action ID
+ */
+export declare function hasCapabilityBehavior(traitType: string, capability: string): boolean;
+/**
+ * Unregister a behavior (primarily for testing).
+ *
+ * @param traitType - The trait type identifier
+ * @param capability - The action ID
+ */
+export declare function unregisterCapabilityBehavior(traitType: string, capability: string): void;
+/**
+ * Clear all registered behaviors (for testing).
+ */
+export declare function clearCapabilityRegistry(): void;
+/**
+ * Get all registered bindings (for debugging/introspection).
+ */
+export declare function getAllCapabilityBindings(): Map<string, TraitBehaviorBinding>;
+//# sourceMappingURL=capability-registry.d.ts.map

package/capabilities/capability-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-registry.d.ts","sourceRoot":"","sources":["../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/capability-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAqB,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE7E;;GAEG;AACH,MAAM,WAAW,2BAA2B,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACpE,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC,4CAA4C;IAC5C,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,kCAAkC;IAClC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC7D,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC,qDAAqD;IACrD,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,kCAAkC;IAClC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;CACzC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,MAAM,EACzD,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACvC,IAAI,CAkBN;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GACjB,kBAAkB,GAAG,SAAS,CAGhC;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GACjB,oBAAoB,GAAG,SAAS,CAiBlC;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAEpF;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAExF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAE5E"}

package/capabilities/capability-registry.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Capability Registry (ADR-090)
+ *
+ * Registry for trait-behavior bindings. Stories register behaviors
+ * for their traits, and the dispatch system looks them up at runtime.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCapabilityBehavior = registerCapabilityBehavior;
+exports.getBehaviorForCapability = getBehaviorForCapability;
+exports.getBehaviorBinding = getBehaviorBinding;
+exports.hasCapabilityBehavior = hasCapabilityBehavior;
+exports.unregisterCapabilityBehavior = unregisterCapabilityBehavior;
+exports.clearCapabilityRegistry = clearCapabilityRegistry;
+exports.getAllCapabilityBindings = getAllCapabilityBindings;
+/**
+ * Registry storage: key = `${traitType}:${capability}`
+ */
+const behaviorRegistry = new Map();
+/**
+ * Generate registry key for trait+capability combination.
+ */
+function registryKey(traitType, capability) {
+    return `${traitType}:${capability}`;
+}
+/**
+ * Register a behavior for a trait+capability combination.
+ *
+ * Stories call this to register their behaviors during initialization.
+ * Each trait+capability pair can only have one behavior registered.
+ *
+ * @param traitType - The trait type identifier (e.g., 'dungeo.trait.basket_elevator')
+ * @param capability - The action ID (e.g., 'if.action.lowering')
+ * @param behavior - The behavior implementation
+ * @param options - Optional configuration (priority, resolution override, mode override)
+ *
+ * @example
+ * ```typescript
+ * // Basic registration (uses global defaults)
+ * registerCapabilityBehavior(
+ *   BasketElevatorTrait.type,
+ *   'if.action.lowering',
+ *   BasketLoweringBehavior
+ * );
+ *
+ * // With priority and overrides
+ * registerCapabilityBehavior(
+ *   TrollAxeTrait.type,
+ *   'if.action.taking',
+ *   TrollAxeTakingBehavior,
+ *   { priority: 100, resolution: 'any-blocks' }
+ * );
+ * ```
+ */
+function registerCapabilityBehavior(traitType, capability, behavior, options) {
+    const key = registryKey(traitType, capability);
+    if (behaviorRegistry.has(key)) {
+        throw new Error(`Behavior already registered for trait "${traitType}" and capability "${capability}"`);
+    }
+    behaviorRegistry.set(key, {
+        traitType,
+        capability,
+        behavior,
+        priority: options?.priority ?? 0,
+        resolution: options?.resolution,
+        mode: options?.mode,
+        validateBinding: options?.validateBinding
+    });
+}
+/**
+ * Get behavior for a trait instance and capability.
+ *
+ * Called by capability-dispatch actions to find the right behavior.
+ *
+ * @param trait - The trait instance
+ * @param capability - The action ID
+ * @returns The behavior, or undefined if not registered
+ */
+function getBehaviorForCapability(trait, capability) {
+    const binding = getBehaviorBinding(trait, capability);
+    return binding?.behavior;
+}
+/**
+ * Get the full binding for a trait instance and capability.
+ *
+ * Includes priority and configuration overrides. Used by dispatch helper
+ * for resolution logic.
+ *
+ * @param trait - The trait instance
+ * @param capability - The action ID
+ * @returns The binding, or undefined if not registered
+ */
+function getBehaviorBinding(trait, capability) {
+    const traitType = trait.constructor.type;
+    const key = registryKey(traitType, capability);
+    const binding = behaviorRegistry.get(key);
+    if (!binding) {
+        return undefined;
+    }
+    // Runtime validation if provided
+    if (binding.validateBinding && !binding.validateBinding(trait)) {
+        throw new Error(`Behavior validation failed for trait "${traitType}", capability "${capability}"`);
+    }
+    return binding;
+}
+/**
+ * Check if a behavior is registered for a trait+capability.
+ *
+ * @param traitType - The trait type identifier
+ * @param capability - The action ID
+ */
+function hasCapabilityBehavior(traitType, capability) {
+    return behaviorRegistry.has(registryKey(traitType, capability));
+}
+/**
+ * Unregister a behavior (primarily for testing).
+ *
+ * @param traitType - The trait type identifier
+ * @param capability - The action ID
+ */
+function unregisterCapabilityBehavior(traitType, capability) {
+    behaviorRegistry.delete(registryKey(traitType, capability));
+}
+/**
+ * Clear all registered behaviors (for testing).
+ */
+function clearCapabilityRegistry() {
+    behaviorRegistry.clear();
+}
+/**
+ * Get all registered bindings (for debugging/introspection).
+ */
+function getAllCapabilityBindings() {
+    return new Map(behaviorRegistry);
+}
+//# sourceMappingURL=capability-registry.js.map

package/capabilities/capability-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-registry.js","sourceRoot":"","sources":["../../../../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/capability-registry.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAiFH,gEAuBC;AAWD,4DAMC;AAYD,gDAoBC;AAQD,sDAEC;AAQD,oEAEC;AAKD,0DAEC;AAKD,4DAEC;AAnJD;;GAEG;AACH,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAgC,CAAC;AAEjE;;GAEG;AACH,SAAS,WAAW,CAAC,SAAiB,EAAE,UAAkB;IACxD,OAAO,GAAG,SAAS,IAAI,UAAU,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,SAAgB,0BAA0B,CACxC,SAAiB,EACjB,UAAkB,EAClB,QAA4B,EAC5B,OAAwC;IAExC,MAAM,GAAG,GAAG,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAE/C,IAAI,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,0CAA0C,SAAS,qBAAqB,UAAU,GAAG,CACtF,CAAC;IACJ,CAAC;IAED,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE;QACxB,SAAS;QACT,UAAU;QACV,QAAQ;QACR,QAAQ,EAAE,OAAO,EAAE,QAAQ,IAAI,CAAC;QAChC,UAAU,EAAE,OAAO,EAAE,UAAU;QAC/B,IAAI,EAAE,OAAO,EAAE,IAAI;QACnB,eAAe,EAAE,OAAO,EAAE,eAA2D;KACtF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,wBAAwB,CACtC,KAAa,EACb,UAAkB;IAElB,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;IACtD,OAAO,OAAO,EAAE,QAAQ,CAAC;AAC3B,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,kBAAkB,CAChC,KAAa,EACb,UAAkB;IAElB,MAAM,SAAS,GAAI,KAAK,CAAC,WAAiC,CAAC,IAAI,CAAC;IAChE,MAAM,GAAG,GAAG,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAC/C,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAE1C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,iCAAiC;IACjC,IAAI,OAAO,CAAC,eAAe,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/D,MAAM,IAAI,KAAK,CACb,yCAAyC,SAAS,kBAAkB,UAAU,GAAG,CAClF,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,qBAAqB,CAAC,SAAiB,EAAE,UAAkB;IACzE,OAAO,gBAAgB,CAAC,GAAG,CAAC,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;AAClE,CAAC;AAED;;;;;GAKG;AACH,SAAgB,4BAA4B,CAAC,SAAiB,EAAE,UAAkB;IAChF,gBAAgB,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED;;GAEG;AACH,SAAgB,uBAAuB;IACrC,gBAAgB,CAAC,KAAK,EAAE,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,SAAgB,wBAAwB;IACtC,OAAO,IAAI,GAAG,CAAC,gBAAgB,CAAC,CAAC;AACnC,CAAC"}

package/capabilities/entity-builder.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Type-Safe Entity Builder (ADR-090)
+ *
+ * Builder pattern for creating entities with compile-time capability
+ * conflict detection. When two traits claim the same capability,
+ * TypeScript will error (and runtime will throw as backup).
+ */
+import { IFEntity } from '../entities';
+import { ITrait } from '../traits/trait';
+/**
+ * Type-safe entity builder that tracks claimed capabilities.
+ *
+ * Provides runtime checks for capability conflicts. TypeScript's
+ * type system can catch conflicts at compile time when traits
+ * declare capabilities with `as const`.
+ *
+ * @example
+ * ```typescript
+ * const basket = new EntityBuilder(entity)
+ *   .add(new IdentityTrait({ name: 'basket' }))
+ *   .add(new ContainerTrait())
+ *   .add(new BasketElevatorTrait({ ... }))  // claims: lowering, raising
+ *   .build();
+ *
+ * // Runtime error - duplicate capability:
+ * const bad = new EntityBuilder(entity)
+ *   .add(new BasketElevatorTrait({ ... }))  // claims: lowering
+ *   .add(new MirrorPoleTrait({ ... }))      // also claims: lowering
+ *   .build();  // throws!
+ * ```
+ */
+export declare class EntityBuilder {
+    private entity;
+    private claimedCaps;
+    constructor(entity: IFEntity);
+    /**
+     * Add a trait to the entity.
+     *
+     * Checks for capability conflicts at runtime. If two traits
+     * claim the same capability, throws an error.
+     *
+     * @param trait - The trait to add
+     * @returns This builder for chaining
+     * @throws Error if capability conflict detected
+     */
+    add<T extends ITrait>(trait: T): this;
+    /**
+     * Build and return the entity.
+     */
+    build(): IFEntity;
+    /**
+     * Get all capabilities claimed so far.
+     */
+    getClaimedCapabilities(): string[];
+    /**
+     * Find which trait claimed a capability.
+     */
+    private findTraitWithCapability;
+}
+/**
+ * Create an entity builder for type-safe trait composition.
+ *
+ * This is a convenience function that wraps an existing entity
+ * in a builder. Use when you want capability conflict checking.
+ *
+ * @param entity - The entity to wrap
+ * @returns A new EntityBuilder
+ *
+ * @example
+ * ```typescript
+ * const basket = buildEntity(world.createEntity('basket', EntityType.CONTAINER))
+ *   .add(new IdentityTrait({ name: 'rusty iron basket' }))
+ *   .add(new ContainerTrait({ capacity: { maxItems: 10 } }))
+ *   .add(new BasketElevatorTrait({ ... }))
+ *   .build();
+ * ```
+ */
+export declare function buildEntity(entity: IFEntity): EntityBuilder;
+//# sourceMappingURL=entity-builder.d.ts.map

package/capabilities/entity-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-builder.d.ts","sourceRoot":"","sources":["../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/entity-builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,iBAAiB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,WAAW,CAAqB;gBAE5B,MAAM,EAAE,QAAQ;IAI5B;;;;;;;;;OASG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAyBrC;;OAEG;IACH,KAAK,IAAI,QAAQ;IAIjB;;OAEG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAIlC;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAShC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,GAAG,aAAa,CAE3D"}

package/capabilities/entity-builder.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Type-Safe Entity Builder (ADR-090)
+ *
+ * Builder pattern for creating entities with compile-time capability
+ * conflict detection. When two traits claim the same capability,
+ * TypeScript will error (and runtime will throw as backup).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBuilder = void 0;
+exports.buildEntity = buildEntity;
+/**
+ * Type-safe entity builder that tracks claimed capabilities.
+ *
+ * Provides runtime checks for capability conflicts. TypeScript's
+ * type system can catch conflicts at compile time when traits
+ * declare capabilities with `as const`.
+ *
+ * @example
+ * ```typescript
+ * const basket = new EntityBuilder(entity)
+ *   .add(new IdentityTrait({ name: 'basket' }))
+ *   .add(new ContainerTrait())
+ *   .add(new BasketElevatorTrait({ ... }))  // claims: lowering, raising
+ *   .build();
+ *
+ * // Runtime error - duplicate capability:
+ * const bad = new EntityBuilder(entity)
+ *   .add(new BasketElevatorTrait({ ... }))  // claims: lowering
+ *   .add(new MirrorPoleTrait({ ... }))      // also claims: lowering
+ *   .build();  // throws!
+ * ```
+ */
+class EntityBuilder {
+    entity;
+    claimedCaps = new Set();
+    constructor(entity) {
+        this.entity = entity;
+    }
+    /**
+     * Add a trait to the entity.
+     *
+     * Checks for capability conflicts at runtime. If two traits
+     * claim the same capability, throws an error.
+     *
+     * @param trait - The trait to add
+     * @returns This builder for chaining
+     * @throws Error if capability conflict detected
+     */
+    add(trait) {
+        const traitClass = trait.constructor;
+        const newCaps = traitClass.capabilities ?? [];
+        // Check for capability conflicts
+        for (const cap of newCaps) {
+            if (this.claimedCaps.has(cap)) {
+                // Find which trait already claimed it
+                const existingTrait = this.findTraitWithCapability(cap);
+                const existingType = existingTrait
+                    ? existingTrait.constructor.type
+                    : 'unknown';
+                throw new Error(`Entity "${this.entity.id}": capability "${cap}" already claimed by trait "${existingType}". ` +
+                    `New trait "${traitClass.type}" cannot also claim it.`);
+            }
+            this.claimedCaps.add(cap);
+        }
+        this.entity.add(trait);
+        return this;
+    }
+    /**
+     * Build and return the entity.
+     */
+    build() {
+        return this.entity;
+    }
+    /**
+     * Get all capabilities claimed so far.
+     */
+    getClaimedCapabilities() {
+        return Array.from(this.claimedCaps);
+    }
+    /**
+     * Find which trait claimed a capability.
+     */
+    findTraitWithCapability(capability) {
+        for (const trait of this.entity.traits.values()) {
+            const traitClass = trait.constructor;
+            if (traitClass.capabilities?.includes(capability)) {
+                return trait;
+            }
+        }
+        return undefined;
+    }
+}
+exports.EntityBuilder = EntityBuilder;
+/**
+ * Create an entity builder for type-safe trait composition.
+ *
+ * This is a convenience function that wraps an existing entity
+ * in a builder. Use when you want capability conflict checking.
+ *
+ * @param entity - The entity to wrap
+ * @returns A new EntityBuilder
+ *
+ * @example
+ * ```typescript
+ * const basket = buildEntity(world.createEntity('basket', EntityType.CONTAINER))
+ *   .add(new IdentityTrait({ name: 'rusty iron basket' }))
+ *   .add(new ContainerTrait({ capacity: { maxItems: 10 } }))
+ *   .add(new BasketElevatorTrait({ ... }))
+ *   .build();
+ * ```
+ */
+function buildEntity(entity) {
+    return new EntityBuilder(entity);
+}
+//# sourceMappingURL=entity-builder.js.map

package/capabilities/entity-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-builder.js","sourceRoot":"","sources":["../../../../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/entity-builder.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAoHH,kCAEC;AAjHD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,aAAa;IAChB,MAAM,CAAW;IACjB,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IAExC,YAAY,MAAgB;QAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAmB,KAAQ;QAC5B,MAAM,UAAU,GAAG,KAAK,CAAC,WAAgC,CAAC;QAC1D,MAAM,OAAO,GAAG,UAAU,CAAC,YAAY,IAAI,EAAE,CAAC;QAE9C,iCAAiC;QACjC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC9B,sCAAsC;gBACtC,MAAM,aAAa,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC;gBACxD,MAAM,YAAY,GAAG,aAAa;oBAChC,CAAC,CAAE,aAAa,CAAC,WAAiC,CAAC,IAAI;oBACvD,CAAC,CAAC,SAAS,CAAC;gBAEd,MAAM,IAAI,KAAK,CACb,WAAW,IAAI,CAAC,MAAM,CAAC,EAAE,kBAAkB,GAAG,+BAA+B,YAAY,KAAK;oBAC9F,cAAc,UAAU,CAAC,IAAI,yBAAyB,CACvD,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,sBAAsB;QACpB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACK,uBAAuB,CAAC,UAAkB;QAChD,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;YAChD,MAAM,UAAU,GAAG,KAAK,CAAC,WAAgC,CAAC;YAC1D,IAAI,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBAClD,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AArED,sCAqEC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,WAAW,CAAC,MAAgB;IAC1C,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC"}

package/capabilities/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Capability Dispatch System (ADR-090)
+ *
+ * Entity-centric action dispatch where traits declare capabilities
+ * (action IDs they respond to) and behaviors implement the logic.
+ */
+export { CapabilityValidationResult, CapabilityEffect, createEffect } from './types';
+export { CapabilityBehavior, CapabilitySharedData } from './capability-behavior';
+export { TraitBehaviorBinding, BehaviorRegistrationOptions, registerCapabilityBehavior, getBehaviorForCapability, getBehaviorBinding, hasCapabilityBehavior, unregisterCapabilityBehavior, clearCapabilityRegistry, getAllCapabilityBindings } from './capability-registry';
+export { CapabilityResolution, CapabilityMode, CapabilityConfig, defineCapabilityDefaults, getCapabilityConfig, hasCapabilityDefaults, clearCapabilityDefaults, getAllCapabilityDefaults } from './capability-defaults';
+export { findTraitWithCapability, hasCapability, getEntityCapabilities, traitHasCapability, getCapableTraits } from './capability-helpers';
+export { EntityBuilder, buildEntity } from './entity-builder';
+export { ActionInterceptor, InterceptorSharedData, InterceptorResult } from './action-interceptor';
+export { TraitInterceptorBinding, InterceptorRegistrationOptions, InterceptorLookupResult, registerActionInterceptor, getInterceptorForAction, getInterceptorBinding, hasActionInterceptor, unregisterActionInterceptor, clearInterceptorRegistry, getAllInterceptorBindings } from './interceptor-registry';
+export { findTraitWithInterceptor, hasInterceptor, getEntityInterceptors, traitHasInterceptor, getInterceptorTraits } from './interceptor-helpers';
+//# sourceMappingURL=index.d.ts.map

package/capabilities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,0BAA0B,EAC1B,gBAAgB,EAChB,YAAY,EACb,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGjF,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,4BAA4B,EAC5B,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,aAAa,EACb,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAW1B,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,uBAAuB,EACvB,yBAAyB,EACzB,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,wBAAwB,EACxB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,uBAAuB,CAAC"}

package/capabilities/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Capability Dispatch System (ADR-090)
+ *
+ * Entity-centric action dispatch where traits declare capabilities
+ * (action IDs they respond to) and behaviors implement the logic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInterceptorTraits = exports.traitHasInterceptor = exports.getEntityInterceptors = exports.hasInterceptor = exports.findTraitWithInterceptor = exports.getAllInterceptorBindings = exports.clearInterceptorRegistry = exports.unregisterActionInterceptor = exports.hasActionInterceptor = exports.getInterceptorBinding = exports.getInterceptorForAction = exports.registerActionInterceptor = exports.buildEntity = exports.EntityBuilder = exports.getCapableTraits = exports.traitHasCapability = exports.getEntityCapabilities = exports.hasCapability = exports.findTraitWithCapability = exports.getAllCapabilityDefaults = exports.clearCapabilityDefaults = exports.hasCapabilityDefaults = exports.getCapabilityConfig = exports.defineCapabilityDefaults = exports.getAllCapabilityBindings = exports.clearCapabilityRegistry = exports.unregisterCapabilityBehavior = exports.hasCapabilityBehavior = exports.getBehaviorBinding = exports.getBehaviorForCapability = exports.registerCapabilityBehavior = exports.createEffect = void 0;
+// Types
+var types_1 = require("./types");
+Object.defineProperty(exports, "createEffect", { enumerable: true, get: function () { return types_1.createEffect; } });
+// Registry
+var capability_registry_1 = require("./capability-registry");
+Object.defineProperty(exports, "registerCapabilityBehavior", { enumerable: true, get: function () { return capability_registry_1.registerCapabilityBehavior; } });
+Object.defineProperty(exports, "getBehaviorForCapability", { enumerable: true, get: function () { return capability_registry_1.getBehaviorForCapability; } });
+Object.defineProperty(exports, "getBehaviorBinding", { enumerable: true, get: function () { return capability_registry_1.getBehaviorBinding; } });
+Object.defineProperty(exports, "hasCapabilityBehavior", { enumerable: true, get: function () { return capability_registry_1.hasCapabilityBehavior; } });
+Object.defineProperty(exports, "unregisterCapabilityBehavior", { enumerable: true, get: function () { return capability_registry_1.unregisterCapabilityBehavior; } });
+Object.defineProperty(exports, "clearCapabilityRegistry", { enumerable: true, get: function () { return capability_registry_1.clearCapabilityRegistry; } });
+Object.defineProperty(exports, "getAllCapabilityBindings", { enumerable: true, get: function () { return capability_registry_1.getAllCapabilityBindings; } });
+// Defaults and configuration
+var capability_defaults_1 = require("./capability-defaults");
+Object.defineProperty(exports, "defineCapabilityDefaults", { enumerable: true, get: function () { return capability_defaults_1.defineCapabilityDefaults; } });
+Object.defineProperty(exports, "getCapabilityConfig", { enumerable: true, get: function () { return capability_defaults_1.getCapabilityConfig; } });
+Object.defineProperty(exports, "hasCapabilityDefaults", { enumerable: true, get: function () { return capability_defaults_1.hasCapabilityDefaults; } });
+Object.defineProperty(exports, "clearCapabilityDefaults", { enumerable: true, get: function () { return capability_defaults_1.clearCapabilityDefaults; } });
+Object.defineProperty(exports, "getAllCapabilityDefaults", { enumerable: true, get: function () { return capability_defaults_1.getAllCapabilityDefaults; } });
+// Helpers
+var capability_helpers_1 = require("./capability-helpers");
+Object.defineProperty(exports, "findTraitWithCapability", { enumerable: true, get: function () { return capability_helpers_1.findTraitWithCapability; } });
+Object.defineProperty(exports, "hasCapability", { enumerable: true, get: function () { return capability_helpers_1.hasCapability; } });
+Object.defineProperty(exports, "getEntityCapabilities", { enumerable: true, get: function () { return capability_helpers_1.getEntityCapabilities; } });
+Object.defineProperty(exports, "traitHasCapability", { enumerable: true, get: function () { return capability_helpers_1.traitHasCapability; } });
+Object.defineProperty(exports, "getCapableTraits", { enumerable: true, get: function () { return capability_helpers_1.getCapableTraits; } });
+// Entity builder
+var entity_builder_1 = require("./entity-builder");
+Object.defineProperty(exports, "EntityBuilder", { enumerable: true, get: function () { return entity_builder_1.EntityBuilder; } });
+Object.defineProperty(exports, "buildEntity", { enumerable: true, get: function () { return entity_builder_1.buildEntity; } });
+// Interceptor registry
+var interceptor_registry_1 = require("./interceptor-registry");
+Object.defineProperty(exports, "registerActionInterceptor", { enumerable: true, get: function () { return interceptor_registry_1.registerActionInterceptor; } });
+Object.defineProperty(exports, "getInterceptorForAction", { enumerable: true, get: function () { return interceptor_registry_1.getInterceptorForAction; } });
+Object.defineProperty(exports, "getInterceptorBinding", { enumerable: true, get: function () { return interceptor_registry_1.getInterceptorBinding; } });
+Object.defineProperty(exports, "hasActionInterceptor", { enumerable: true, get: function () { return interceptor_registry_1.hasActionInterceptor; } });
+Object.defineProperty(exports, "unregisterActionInterceptor", { enumerable: true, get: function () { return interceptor_registry_1.unregisterActionInterceptor; } });
+Object.defineProperty(exports, "clearInterceptorRegistry", { enumerable: true, get: function () { return interceptor_registry_1.clearInterceptorRegistry; } });
+Object.defineProperty(exports, "getAllInterceptorBindings", { enumerable: true, get: function () { return interceptor_registry_1.getAllInterceptorBindings; } });
+// Interceptor helpers
+var interceptor_helpers_1 = require("./interceptor-helpers");
+Object.defineProperty(exports, "findTraitWithInterceptor", { enumerable: true, get: function () { return interceptor_helpers_1.findTraitWithInterceptor; } });
+Object.defineProperty(exports, "hasInterceptor", { enumerable: true, get: function () { return interceptor_helpers_1.hasInterceptor; } });
+Object.defineProperty(exports, "getEntityInterceptors", { enumerable: true, get: function () { return interceptor_helpers_1.getEntityInterceptors; } });
+Object.defineProperty(exports, "traitHasInterceptor", { enumerable: true, get: function () { return interceptor_helpers_1.traitHasInterceptor; } });
+Object.defineProperty(exports, "getInterceptorTraits", { enumerable: true, get: function () { return interceptor_helpers_1.getInterceptorTraits; } });
+//# sourceMappingURL=index.js.map

package/capabilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,QAAQ;AACR,iCAIiB;AADf,qGAAA,YAAY,OAAA;AAMd,WAAW;AACX,6DAU+B;AAP7B,iIAAA,0BAA0B,OAAA;AAC1B,+HAAA,wBAAwB,OAAA;AACxB,yHAAA,kBAAkB,OAAA;AAClB,4HAAA,qBAAqB,OAAA;AACrB,mIAAA,4BAA4B,OAAA;AAC5B,8HAAA,uBAAuB,OAAA;AACvB,+HAAA,wBAAwB,OAAA;AAG1B,6BAA6B;AAC7B,6DAS+B;AAL7B,+HAAA,wBAAwB,OAAA;AACxB,0HAAA,mBAAmB,OAAA;AACnB,4HAAA,qBAAqB,OAAA;AACrB,8HAAA,uBAAuB,OAAA;AACvB,+HAAA,wBAAwB,OAAA;AAG1B,UAAU;AACV,2DAM8B;AAL5B,6HAAA,uBAAuB,OAAA;AACvB,mHAAA,aAAa,OAAA;AACb,2HAAA,qBAAqB,OAAA;AACrB,wHAAA,kBAAkB,OAAA;AAClB,sHAAA,gBAAgB,OAAA;AAGlB,iBAAiB;AACjB,mDAG0B;AAFxB,+GAAA,aAAa,OAAA;AACb,6GAAA,WAAW,OAAA;AAkBb,uBAAuB;AACvB,+DAWgC;AAP9B,iIAAA,yBAAyB,OAAA;AACzB,+HAAA,uBAAuB,OAAA;AACvB,6HAAA,qBAAqB,OAAA;AACrB,4HAAA,oBAAoB,OAAA;AACpB,mIAAA,2BAA2B,OAAA;AAC3B,gIAAA,wBAAwB,OAAA;AACxB,iIAAA,yBAAyB,OAAA;AAG3B,sBAAsB;AACtB,6DAM+B;AAL7B,+HAAA,wBAAwB,OAAA;AACxB,qHAAA,cAAc,OAAA;AACd,4HAAA,qBAAqB,OAAA;AACrB,0HAAA,mBAAmB,OAAA;AACnB,2HAAA,oBAAoB,OAAA"}

package/capabilities/interceptor-helpers.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Interceptor Helpers (ADR-118)
+ *
+ * Helper functions for working with trait interceptors.
+ * Mirrors capability-helpers.ts pattern but for interceptors.
+ */
+import { ITrait } from '../traits/trait';
+import { IFEntity } from '../entities';
+/**
+ * Find a trait on the entity that has an interceptor registered for the given action.
+ *
+ * Note: This checks both the static `interceptors` declaration on the trait class
+ * AND the registry. Use this when you need the trait instance.
+ *
+ * @param entity - The entity to search
+ * @param actionId - The action ID to find
+ * @returns The trait that has an interceptor registered, or undefined
+ *
+ * @example
+ * ```typescript
+ * const trait = findTraitWithInterceptor(boat, 'if.action.entering');
+ * if (trait) {
+ *   // Entity has an interceptor for entering
+ * }
+ * ```
+ */
+export declare function findTraitWithInterceptor(entity: IFEntity, actionId: string): ITrait | undefined;
+/**
+ * Check if an entity has any trait declaring an interceptor for an action.
+ *
+ * @param entity - The entity to check
+ * @param actionId - The action ID to check for
+ * @returns True if entity has a trait with this interceptor
+ *
+ * @example
+ * ```typescript
+ * if (hasInterceptor(entity, 'if.action.entering')) {
+ *   // Entity can intercept entering actions
+ * }
+ * ```
+ */
+export declare function hasInterceptor(entity: IFEntity, actionId: string): boolean;
+/**
+ * Get all interceptor action IDs declared by an entity's traits.
+ *
+ * @param entity - The entity to inspect
+ * @returns Array of action IDs the entity intercepts
+ */
+export declare function getEntityInterceptors(entity: IFEntity): string[];
+/**
+ * Type guard to check if a trait declares a specific interceptor.
+ *
+ * @param trait - The trait to check
+ * @param actionId - The action ID to check for
+ * @param traitType - Optional: specific trait class to narrow to
+ * @returns True if trait has the interceptor (and is of specified type)
+ *
+ * @example
+ * ```typescript
+ * if (traitHasInterceptor(trait, 'if.action.entering', InflatableTrait)) {
+ *   // trait is narrowed to InflatableTrait
+ *   console.log(trait.isInflated);
+ * }
+ * ```
+ */
+export declare function traitHasInterceptor<T extends ITrait>(trait: ITrait, actionId: string, traitType?: new (...args: unknown[]) => T): trait is T;
+/**
+ * Find all traits on an entity that have interceptors.
+ *
+ * @param entity - The entity to inspect
+ * @returns Array of traits that declare at least one interceptor
+ */
+export declare function getInterceptorTraits(entity: IFEntity): ITrait[];
+//# sourceMappingURL=interceptor-helpers.d.ts.map

package/capabilities/interceptor-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor-helpers.d.ts","sourceRoot":"","sources":["../../../../../../mnt/c/repotemp/sharpee/packages/world-model/src/capabilities/interceptor-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAqB,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,QAAQ,EAChB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CASpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,EAAE,CAWhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAClD,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,GACxC,KAAK,IAAI,CAAC,CAQZ;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,EAAE,CAK/D"}