@sharpee/core 0.9.56-beta

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 David Cornelson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# @sharpee/core
+
+Core types, interfaces, and utilities for the Sharpee Interactive Fiction platform.
+
+## Installation
+
+```bash
+npm install @sharpee/core
+```
+
+## Overview
+
+This package provides the foundational types used across all Sharpee packages:
+
+- **Event System** - `SemanticEvent`, typed event registry, event helpers
+- **Query System** - `QueryManager` for player input (yes/no, menus)
+- **Platform Events** - Save, restore, quit, restart handling
+- **Core Utilities** - Common interfaces and type definitions
+
+## Usage
+
+```typescript
+import {
+  SemanticEvent,
+  createTypedEvent,
+  isEventType,
+  QueryManager,
+  PlatformEventType
+} from '@sharpee/core';
+
+// Create typed events
+const event = createTypedEvent('game.started', { timestamp: Date.now() });
+
+// Type-safe event checking
+if (isEventType(event, 'game.started')) {
+  console.log(event.data.timestamp);
+}
+```
+
+## Related Packages
+
+- [@sharpee/sharpee](https://www.npmjs.com/package/@sharpee/sharpee) - Full platform bundle
+- [@sharpee/engine](https://www.npmjs.com/package/@sharpee/engine) - Game runtime
+- [@sharpee/world-model](https://www.npmjs.com/package/@sharpee/world-model) - Entity system
+
+## License
+
+MIT

package/dist/constants/attributes.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Core entity attributes - generic attributes that any entity might have
+ * Game-specific attributes should be defined in their respective packages
+ */
+export declare enum CoreAttributes {
+    ID = "id",
+    TYPE = "type",
+    NAME = "name",
+    CREATED_AT = "created_at",
+    UPDATED_AT = "updated_at",
+    VERSION = "version",
+    ACTIVE = "active",
+    VISIBLE = "visible",
+    EXTENSIONS = "extensions",
+    METADATA = "metadata"
+}
+/**
+ * Core attribute types for validation
+ */
+export declare enum CoreAttributeType {
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    OBJECT = "object",
+    ARRAY = "array",
+    DATE = "date"
+}
+/**
+ * Core attribute definitions with their expected types
+ */
+export declare const CORE_ATTRIBUTE_TYPES: Record<CoreAttributes, CoreAttributeType>;
+//# sourceMappingURL=attributes.d.ts.map

package/dist/constants/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../src/constants/attributes.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oBAAY,cAAc;IAExB,EAAE,OAAO;IACT,IAAI,SAAS;IACb,IAAI,SAAS;IAGb,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,OAAO,YAAY;IAGnB,MAAM,WAAW;IACjB,OAAO,YAAY;IAGnB,UAAU,eAAe;IACzB,QAAQ,aAAa;CACtB;AAED;;GAEG;AACH,oBAAY,iBAAiB;IAC3B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,cAAc,EAAE,iBAAiB,CAW1E,CAAC"}

package/dist/constants/attributes.js

@@ -0,0 +1,53 @@
+"use strict";
+// packages/core/src/constants/attributes.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_ATTRIBUTE_TYPES = exports.CoreAttributeType = exports.CoreAttributes = void 0;
+/**
+ * Core entity attributes - generic attributes that any entity might have
+ * Game-specific attributes should be defined in their respective packages
+ */
+var CoreAttributes;
+(function (CoreAttributes) {
+    // Identity attributes
+    CoreAttributes["ID"] = "id";
+    CoreAttributes["TYPE"] = "type";
+    CoreAttributes["NAME"] = "name";
+    // Metadata attributes
+    CoreAttributes["CREATED_AT"] = "created_at";
+    CoreAttributes["UPDATED_AT"] = "updated_at";
+    CoreAttributes["VERSION"] = "version";
+    // State attributes
+    CoreAttributes["ACTIVE"] = "active";
+    CoreAttributes["VISIBLE"] = "visible";
+    // Extension attributes
+    CoreAttributes["EXTENSIONS"] = "extensions";
+    CoreAttributes["METADATA"] = "metadata";
+})(CoreAttributes || (exports.CoreAttributes = CoreAttributes = {}));
+/**
+ * Core attribute types for validation
+ */
+var CoreAttributeType;
+(function (CoreAttributeType) {
+    CoreAttributeType["STRING"] = "string";
+    CoreAttributeType["NUMBER"] = "number";
+    CoreAttributeType["BOOLEAN"] = "boolean";
+    CoreAttributeType["OBJECT"] = "object";
+    CoreAttributeType["ARRAY"] = "array";
+    CoreAttributeType["DATE"] = "date";
+})(CoreAttributeType || (exports.CoreAttributeType = CoreAttributeType = {}));
+/**
+ * Core attribute definitions with their expected types
+ */
+exports.CORE_ATTRIBUTE_TYPES = {
+    [CoreAttributes.ID]: CoreAttributeType.STRING,
+    [CoreAttributes.TYPE]: CoreAttributeType.STRING,
+    [CoreAttributes.NAME]: CoreAttributeType.STRING,
+    [CoreAttributes.CREATED_AT]: CoreAttributeType.DATE,
+    [CoreAttributes.UPDATED_AT]: CoreAttributeType.DATE,
+    [CoreAttributes.VERSION]: CoreAttributeType.NUMBER,
+    [CoreAttributes.ACTIVE]: CoreAttributeType.BOOLEAN,
+    [CoreAttributes.VISIBLE]: CoreAttributeType.BOOLEAN,
+    [CoreAttributes.EXTENSIONS]: CoreAttributeType.ARRAY,
+    [CoreAttributes.METADATA]: CoreAttributeType.OBJECT
+};
+//# sourceMappingURL=attributes.js.map

package/dist/constants/attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.js","sourceRoot":"","sources":["../../src/constants/attributes.ts"],"names":[],"mappings":";AAAA,4CAA4C;;;AAE5C;;;GAGG;AACH,IAAY,cAkBX;AAlBD,WAAY,cAAc;IACxB,sBAAsB;IACtB,2BAAS,CAAA;IACT,+BAAa,CAAA;IACb,+BAAa,CAAA;IAEb,sBAAsB;IACtB,2CAAyB,CAAA;IACzB,2CAAyB,CAAA;IACzB,qCAAmB,CAAA;IAEnB,mBAAmB;IACnB,mCAAiB,CAAA;IACjB,qCAAmB,CAAA;IAEnB,uBAAuB;IACvB,2CAAyB,CAAA;IACzB,uCAAqB,CAAA;AACvB,CAAC,EAlBW,cAAc,8BAAd,cAAc,QAkBzB;AAED;;GAEG;AACH,IAAY,iBAOX;AAPD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,sCAAiB,CAAA;IACjB,wCAAmB,CAAA;IACnB,sCAAiB,CAAA;IACjB,oCAAe,CAAA;IACf,kCAAa,CAAA;AACf,CAAC,EAPW,iBAAiB,iCAAjB,iBAAiB,QAO5B;AAED;;GAEG;AACU,QAAA,oBAAoB,GAA8C;IAC7E,CAAC,cAAc,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,MAAM;IAC7C,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC,MAAM;IAC/C,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC,MAAM;IAC/C,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,iBAAiB,CAAC,IAAI;IACnD,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,iBAAiB,CAAC,IAAI;IACnD,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC,MAAM;IAClD,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC,OAAO;IAClD,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC,OAAO;IACnD,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,iBAAiB,CAAC,KAAK;IACpD,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC,MAAM;CACpD,CAAC"}

package/dist/constants/core-events.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Core system events - generic events that any narrative system might use
+ * These are infrastructure-level events, not game-specific
+ */
+export declare enum CoreEvents {
+    SYSTEM_INITIALIZED = "core.system.initialized",
+    SYSTEM_SHUTDOWN = "core.system.shutdown",
+    STATE_CHANGED = "core.state.changed",
+    STATE_RESTORED = "core.state.restored",
+    ENTITY_CREATED = "core.entity.created",
+    ENTITY_UPDATED = "core.entity.updated",
+    ENTITY_DESTROYED = "core.entity.destroyed",
+    RELATIONSHIP_CREATED = "core.relationship.created",
+    RELATIONSHIP_UPDATED = "core.relationship.updated",
+    RELATIONSHIP_DESTROYED = "core.relationship.destroyed",
+    COMMAND_RECEIVED = "core.command.received",
+    COMMAND_PARSED = "core.command.parsed",
+    COMMAND_EXECUTED = "core.command.executed",
+    COMMAND_FAILED = "core.command.failed",
+    EXTENSION_LOADED = "core.extension.loaded",
+    EXTENSION_UNLOADED = "core.extension.unloaded",
+    ERROR_OCCURRED = "core.error.occurred",
+    WARNING_RAISED = "core.warning.raised"
+}
+/**
+ * Core event categories for filtering
+ */
+export declare enum CoreEventCategory {
+    SYSTEM = "system",
+    STATE = "state",
+    ENTITY = "entity",
+    RELATIONSHIP = "relationship",
+    COMMAND = "command",
+    EXTENSION = "extension",
+    ERROR = "error"
+}
+//# sourceMappingURL=core-events.d.ts.map

package/dist/constants/core-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-events.d.ts","sourceRoot":"","sources":["../../src/constants/core-events.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oBAAY,UAAU;IAEpB,kBAAkB,4BAA4B;IAC9C,eAAe,yBAAyB;IAGxC,aAAa,uBAAuB;IACpC,cAAc,wBAAwB;IAGtC,cAAc,wBAAwB;IACtC,cAAc,wBAAwB;IACtC,gBAAgB,0BAA0B;IAG1C,oBAAoB,8BAA8B;IAClD,oBAAoB,8BAA8B;IAClD,sBAAsB,gCAAgC;IAGtD,gBAAgB,0BAA0B;IAC1C,cAAc,wBAAwB;IACtC,gBAAgB,0BAA0B;IAC1C,cAAc,wBAAwB;IAGtC,gBAAgB,0BAA0B;IAC1C,kBAAkB,4BAA4B;IAG9C,cAAc,wBAAwB;IACtC,cAAc,wBAAwB;CACvC;AAED;;GAEG;AACH,oBAAY,iBAAiB;IAC3B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,YAAY,iBAAiB;IAC7B,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,KAAK,UAAU;CAChB"}

package/dist/constants/core-events.js

@@ -0,0 +1,50 @@
+"use strict";
+// packages/core/src/constants/core-events.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreEventCategory = exports.CoreEvents = void 0;
+/**
+ * Core system events - generic events that any narrative system might use
+ * These are infrastructure-level events, not game-specific
+ */
+var CoreEvents;
+(function (CoreEvents) {
+    // System lifecycle events
+    CoreEvents["SYSTEM_INITIALIZED"] = "core.system.initialized";
+    CoreEvents["SYSTEM_SHUTDOWN"] = "core.system.shutdown";
+    // State management events
+    CoreEvents["STATE_CHANGED"] = "core.state.changed";
+    CoreEvents["STATE_RESTORED"] = "core.state.restored";
+    // Entity lifecycle events
+    CoreEvents["ENTITY_CREATED"] = "core.entity.created";
+    CoreEvents["ENTITY_UPDATED"] = "core.entity.updated";
+    CoreEvents["ENTITY_DESTROYED"] = "core.entity.destroyed";
+    // Relationship events
+    CoreEvents["RELATIONSHIP_CREATED"] = "core.relationship.created";
+    CoreEvents["RELATIONSHIP_UPDATED"] = "core.relationship.updated";
+    CoreEvents["RELATIONSHIP_DESTROYED"] = "core.relationship.destroyed";
+    // Command processing events
+    CoreEvents["COMMAND_RECEIVED"] = "core.command.received";
+    CoreEvents["COMMAND_PARSED"] = "core.command.parsed";
+    CoreEvents["COMMAND_EXECUTED"] = "core.command.executed";
+    CoreEvents["COMMAND_FAILED"] = "core.command.failed";
+    // Extension events
+    CoreEvents["EXTENSION_LOADED"] = "core.extension.loaded";
+    CoreEvents["EXTENSION_UNLOADED"] = "core.extension.unloaded";
+    // Error events
+    CoreEvents["ERROR_OCCURRED"] = "core.error.occurred";
+    CoreEvents["WARNING_RAISED"] = "core.warning.raised";
+})(CoreEvents || (exports.CoreEvents = CoreEvents = {}));
+/**
+ * Core event categories for filtering
+ */
+var CoreEventCategory;
+(function (CoreEventCategory) {
+    CoreEventCategory["SYSTEM"] = "system";
+    CoreEventCategory["STATE"] = "state";
+    CoreEventCategory["ENTITY"] = "entity";
+    CoreEventCategory["RELATIONSHIP"] = "relationship";
+    CoreEventCategory["COMMAND"] = "command";
+    CoreEventCategory["EXTENSION"] = "extension";
+    CoreEventCategory["ERROR"] = "error";
+})(CoreEventCategory || (exports.CoreEventCategory = CoreEventCategory = {}));
+//# sourceMappingURL=core-events.js.map

package/dist/constants/core-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-events.js","sourceRoot":"","sources":["../../src/constants/core-events.ts"],"names":[],"mappings":";AAAA,6CAA6C;;;AAE7C;;;GAGG;AACH,IAAY,UAgCX;AAhCD,WAAY,UAAU;IACpB,0BAA0B;IAC1B,4DAA8C,CAAA;IAC9C,sDAAwC,CAAA;IAExC,0BAA0B;IAC1B,kDAAoC,CAAA;IACpC,oDAAsC,CAAA;IAEtC,0BAA0B;IAC1B,oDAAsC,CAAA;IACtC,oDAAsC,CAAA;IACtC,wDAA0C,CAAA;IAE1C,sBAAsB;IACtB,gEAAkD,CAAA;IAClD,gEAAkD,CAAA;IAClD,oEAAsD,CAAA;IAEtD,4BAA4B;IAC5B,wDAA0C,CAAA;IAC1C,oDAAsC,CAAA;IACtC,wDAA0C,CAAA;IAC1C,oDAAsC,CAAA;IAEtC,mBAAmB;IACnB,wDAA0C,CAAA;IAC1C,4DAA8C,CAAA;IAE9C,eAAe;IACf,oDAAsC,CAAA;IACtC,oDAAsC,CAAA;AACxC,CAAC,EAhCW,UAAU,0BAAV,UAAU,QAgCrB;AAED;;GAEG;AACH,IAAY,iBAQX;AARD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,oCAAe,CAAA;IACf,sCAAiB,CAAA;IACjB,kDAA6B,CAAA;IAC7B,wCAAmB,CAAA;IACnB,4CAAuB,CAAA;IACvB,oCAAe,CAAA;AACjB,CAAC,EARW,iBAAiB,iCAAjB,iBAAiB,QAQ5B"}

package/dist/constants/entity-types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Core entity types - generic types that any system might use
+ * Game-specific types should be defined in their respective packages
+ */
+export declare enum CoreEntityType {
+    ENTITY = "core.entity",
+    COMPONENT = "core.component",
+    SYSTEM = "core.system",
+    EXTENSION = "core.extension"
+}
+/**
+ * Type guard for core entity types
+ */
+export declare function isCoreEntityType(type: string): type is CoreEntityType;
+//# sourceMappingURL=entity-types.d.ts.map

package/dist/constants/entity-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-types.d.ts","sourceRoot":"","sources":["../../src/constants/entity-types.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oBAAY,cAAc;IAExB,MAAM,gBAAgB;IAGtB,SAAS,mBAAmB;IAG5B,MAAM,gBAAgB;IAGtB,SAAS,mBAAmB;CAC7B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,cAAc,CAErE"}

package/dist/constants/entity-types.js

@@ -0,0 +1,27 @@
+"use strict";
+// packages/core/src/constants/entity-types.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreEntityType = void 0;
+exports.isCoreEntityType = isCoreEntityType;
+/**
+ * Core entity types - generic types that any system might use
+ * Game-specific types should be defined in their respective packages
+ */
+var CoreEntityType;
+(function (CoreEntityType) {
+    // Base entity type
+    CoreEntityType["ENTITY"] = "core.entity";
+    // Component entities (for ECS-style systems)
+    CoreEntityType["COMPONENT"] = "core.component";
+    // System entities
+    CoreEntityType["SYSTEM"] = "core.system";
+    // Extension entities
+    CoreEntityType["EXTENSION"] = "core.extension";
+})(CoreEntityType || (exports.CoreEntityType = CoreEntityType = {}));
+/**
+ * Type guard for core entity types
+ */
+function isCoreEntityType(type) {
+    return Object.values(CoreEntityType).includes(type);
+}
+//# sourceMappingURL=entity-types.js.map

package/dist/constants/entity-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-types.js","sourceRoot":"","sources":["../../src/constants/entity-types.ts"],"names":[],"mappings":";AAAA,8CAA8C;;;AAuB9C,4CAEC;AAvBD;;;GAGG;AACH,IAAY,cAYX;AAZD,WAAY,cAAc;IACxB,mBAAmB;IACnB,wCAAsB,CAAA;IAEtB,6CAA6C;IAC7C,8CAA4B,CAAA;IAE5B,kBAAkB;IAClB,wCAAsB,CAAA;IAEtB,qBAAqB;IACrB,8CAA4B,CAAA;AAC9B,CAAC,EAZW,cAAc,8BAAd,cAAc,QAYzB;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAAC,IAAY;IAC3C,OAAO,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC,IAAsB,CAAC,CAAC;AACxE,CAAC"}

package/dist/constants/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Core constants for Sharpee
+ *
+ * These are generic, system-level constants that don't assume any particular
+ * type of narrative or game. IF-specific constants are in @sharpee/stdlib.
+ */
+export * from './entity-types';
+export * from './relationships';
+export * from './attributes';
+export * from './core-events';
+import { CoreEntityType } from './entity-types';
+import { CoreRelationshipType } from './relationships';
+import { CoreAttributes } from './attributes';
+import { CoreEvents, CoreEventCategory } from './core-events';
+export declare const CoreConstants: {
+    readonly EntityTypes: typeof CoreEntityType;
+    readonly Relationships: typeof CoreRelationshipType;
+    readonly Attributes: typeof CoreAttributes;
+    readonly Events: typeof CoreEvents;
+    readonly EventCategories: typeof CoreEventCategory;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAG9B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE9D,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC"}

package/dist/constants/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Core constants for Sharpee
+ *
+ * These are generic, system-level constants that don't assume any particular
+ * type of narrative or game. IF-specific constants are in @sharpee/stdlib.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreConstants = void 0;
+// Export generic constants only
+__exportStar(require("./entity-types"), exports);
+__exportStar(require("./relationships"), exports);
+__exportStar(require("./attributes"), exports);
+__exportStar(require("./core-events"), exports);
+// Convenience export
+const entity_types_1 = require("./entity-types");
+const relationships_1 = require("./relationships");
+const attributes_1 = require("./attributes");
+const core_events_1 = require("./core-events");
+exports.CoreConstants = {
+    EntityTypes: entity_types_1.CoreEntityType,
+    Relationships: relationships_1.CoreRelationshipType,
+    Attributes: attributes_1.CoreAttributes,
+    Events: core_events_1.CoreEvents,
+    EventCategories: core_events_1.CoreEventCategory
+};
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;;;;;;;;;;;;;;;AAEH,gCAAgC;AAChC,iDAA+B;AAC/B,kDAAgC;AAChC,+CAA6B;AAC7B,gDAA8B;AAE9B,qBAAqB;AACrB,iDAAgD;AAChD,mDAAuD;AACvD,6CAA8C;AAC9C,+CAA8D;AAEjD,QAAA,aAAa,GAAG;IAC3B,WAAW,EAAE,6BAAc;IAC3B,aAAa,EAAE,oCAAoB;IACnC,UAAU,EAAE,2BAAc;IAC1B,MAAM,EAAE,wBAAU;IAClB,eAAe,EAAE,+BAAiB;CAC1B,CAAC"}

package/dist/constants/relationships.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Core relationship types - generic relationships that any system might use
+ * Game-specific relationships should be defined in their respective packages
+ */
+export declare enum CoreRelationshipType {
+    PARENT = "core.parent",
+    CHILD = "core.child",
+    RELATED_TO = "core.related_to",
+    DEPENDS_ON = "core.depends_on",
+    HAS_COMPONENT = "core.has_component",
+    COMPONENT_OF = "core.component_of"
+}
+/**
+ * Configuration for core relationships
+ */
+export interface ICoreRelationshipConfig {
+    bidirectional?: boolean;
+    inverse?: CoreRelationshipType;
+    exclusive?: boolean;
+}
+/**
+ * Standard configurations for core relationships
+ */
+export declare const CORE_RELATIONSHIP_CONFIGS: Record<CoreRelationshipType, ICoreRelationshipConfig>;
+//# sourceMappingURL=relationships.d.ts.map

package/dist/constants/relationships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../src/constants/relationships.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oBAAY,oBAAoB;IAE9B,MAAM,gBAAgB;IACtB,KAAK,eAAe;IAGpB,UAAU,oBAAoB;IAC9B,UAAU,oBAAoB;IAG9B,aAAa,uBAAuB;IACpC,YAAY,sBAAsB;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,oBAAoB,EAAE,uBAAuB,CA8B3F,CAAC"}

package/dist/constants/relationships.js

@@ -0,0 +1,55 @@
+"use strict";
+// packages/core/src/constants/relationships.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_RELATIONSHIP_CONFIGS = exports.CoreRelationshipType = void 0;
+/**
+ * Core relationship types - generic relationships that any system might use
+ * Game-specific relationships should be defined in their respective packages
+ */
+var CoreRelationshipType;
+(function (CoreRelationshipType) {
+    // Basic hierarchical relationships
+    CoreRelationshipType["PARENT"] = "core.parent";
+    CoreRelationshipType["CHILD"] = "core.child";
+    // Generic associations
+    CoreRelationshipType["RELATED_TO"] = "core.related_to";
+    CoreRelationshipType["DEPENDS_ON"] = "core.depends_on";
+    // Component relationships (for ECS-style systems)
+    CoreRelationshipType["HAS_COMPONENT"] = "core.has_component";
+    CoreRelationshipType["COMPONENT_OF"] = "core.component_of";
+})(CoreRelationshipType || (exports.CoreRelationshipType = CoreRelationshipType = {}));
+/**
+ * Standard configurations for core relationships
+ */
+exports.CORE_RELATIONSHIP_CONFIGS = {
+    [CoreRelationshipType.PARENT]: {
+        bidirectional: true,
+        inverse: CoreRelationshipType.CHILD,
+        exclusive: true
+    },
+    [CoreRelationshipType.CHILD]: {
+        bidirectional: true,
+        inverse: CoreRelationshipType.PARENT,
+        exclusive: false
+    },
+    [CoreRelationshipType.RELATED_TO]: {
+        bidirectional: true,
+        inverse: CoreRelationshipType.RELATED_TO,
+        exclusive: false
+    },
+    [CoreRelationshipType.DEPENDS_ON]: {
+        bidirectional: false,
+        exclusive: false
+    },
+    [CoreRelationshipType.HAS_COMPONENT]: {
+        bidirectional: true,
+        inverse: CoreRelationshipType.COMPONENT_OF,
+        exclusive: false
+    },
+    [CoreRelationshipType.COMPONENT_OF]: {
+        bidirectional: true,
+        inverse: CoreRelationshipType.HAS_COMPONENT,
+        exclusive: true
+    }
+};
+//# sourceMappingURL=relationships.js.map

package/dist/constants/relationships.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationships.js","sourceRoot":"","sources":["../../src/constants/relationships.ts"],"names":[],"mappings":";AAAA,+CAA+C;;;AAE/C;;;GAGG;AACH,IAAY,oBAYX;AAZD,WAAY,oBAAoB;IAC9B,mCAAmC;IACnC,8CAAsB,CAAA;IACtB,4CAAoB,CAAA;IAEpB,uBAAuB;IACvB,sDAA8B,CAAA;IAC9B,sDAA8B,CAAA;IAE9B,kDAAkD;IAClD,4DAAoC,CAAA;IACpC,0DAAkC,CAAA;AACpC,CAAC,EAZW,oBAAoB,oCAApB,oBAAoB,QAY/B;AAWD;;GAEG;AACU,QAAA,yBAAyB,GAA0D;IAC9F,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAE;QAC7B,aAAa,EAAE,IAAI;QACnB,OAAO,EAAE,oBAAoB,CAAC,KAAK;QACnC,SAAS,EAAE,IAAI;KAChB;IACD,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE;QAC5B,aAAa,EAAE,IAAI;QACnB,OAAO,EAAE,oBAAoB,CAAC,MAAM;QACpC,SAAS,EAAE,KAAK;KACjB;IACD,CAAC,oBAAoB,CAAC,UAAU,CAAC,EAAE;QACjC,aAAa,EAAE,IAAI;QACnB,OAAO,EAAE,oBAAoB,CAAC,UAAU;QACxC,SAAS,EAAE,KAAK;KACjB;IACD,CAAC,oBAAoB,CAAC,UAAU,CAAC,EAAE;QACjC,aAAa,EAAE,KAAK;QACpB,SAAS,EAAE,KAAK;KACjB;IACD,CAAC,oBAAoB,CAAC,aAAa,CAAC,EAAE;QACpC,aAAa,EAAE,IAAI;QACnB,OAAO,EAAE,oBAAoB,CAAC,YAAY;QAC1C,SAAS,EAAE,KAAK;KACjB;IACD,CAAC,oBAAoB,CAAC,YAAY,CAAC,EAAE;QACnC,aAAa,EAAE,IAAI;QACnB,OAAO,EAAE,oBAAoB,CAAC,aAAa;QAC3C,SAAS,EAAE,IAAI;KAChB;CACF,CAAC"}

package/dist/debug/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Debug types for diagnostic information
+ */
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/debug/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAC"}

package/dist/debug/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Debug types for diagnostic information
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/debug/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/debug/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;;;;;;;;;;;;;AAEH,0CAAwB"}

package/dist/debug/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Debug event types for diagnostic information.
+ * These are separate from semantic events and used for development/debugging.
+ */
+/**
+ * Debug event emitted by various subsystems for diagnostic purposes.
+ * These events are NOT part of the game's semantic event system.
+ */
+export interface IDebugEvent {
+    /** Unique identifier for this debug event */
+    id: string;
+    /** When the event was emitted */
+    timestamp: number;
+    /** Which subsystem emitted this event */
+    subsystem: 'parser' | 'validator' | 'executor' | 'world-model' | 'text-service';
+    /** Type of debug event within the subsystem */
+    type: string;
+    /** Event-specific data */
+    data: any;
+}
+/**
+ * Callback function for receiving debug events
+ */
+export type DebugEventCallback = (event: IDebugEvent) => void;
+/**
+ * Context for debug event emission, passed to subsystems
+ */
+export interface IDebugContext {
+    /** Optional callback to emit debug events */
+    emit?: DebugEventCallback;
+    /** Whether debug events are enabled */
+    enabled: boolean;
+}
+/**
+ * Common debug event types by subsystem
+ */
+export declare const DebugEventTypes: {
+    readonly parser: {
+        readonly TOKEN_ANALYSIS: "token_analysis";
+        readonly PATTERN_MATCH: "pattern_match";
+        readonly CANDIDATE_SCORING: "candidate_scoring";
+    };
+    readonly validator: {
+        readonly ENTITY_RESOLUTION: "entity_resolution";
+        readonly SCOPE_CHECK: "scope_check";
+        readonly AMBIGUITY_RESOLUTION: "ambiguity_resolution";
+        readonly VALIDATION_ERROR: "validation_error";
+    };
+    readonly executor: {
+        readonly ACTION_START: "action_start";
+        readonly ACTION_COMPLETE: "action_complete";
+        readonly ACTION_ERROR: "action_error";
+    };
+    readonly worldModel: {
+        readonly ENTITY_CHANGE: "entity_change";
+        readonly RELATION_CHANGE: "relation_change";
+        readonly PROPERTY_CHANGE: "property_change";
+    };
+    readonly textService: {
+        readonly TEMPLATE_SELECTION: "template_selection";
+        readonly TEXT_GENERATION: "text_generation";
+        readonly CHANNEL_ROUTING: "channel_routing";
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/debug/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/debug/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAC;IAEX,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;IAElB,yCAAyC;IACzC,SAAS,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,cAAc,CAAC;IAEhF,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IAEb,0BAA0B;IAC1B,IAAI,EAAE,GAAG,CAAC;CACX;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAE1B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,CAAC"}

package/dist/debug/types.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Debug event types for diagnostic information.
+ * These are separate from semantic events and used for development/debugging.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugEventTypes = void 0;
+/**
+ * Common debug event types by subsystem
+ */
+exports.DebugEventTypes = {
+    parser: {
+        TOKEN_ANALYSIS: 'token_analysis',
+        PATTERN_MATCH: 'pattern_match',
+        CANDIDATE_SCORING: 'candidate_scoring',
+    },
+    validator: {
+        ENTITY_RESOLUTION: 'entity_resolution',
+        SCOPE_CHECK: 'scope_check',
+        AMBIGUITY_RESOLUTION: 'ambiguity_resolution',
+        VALIDATION_ERROR: 'validation_error',
+    },
+    executor: {
+        ACTION_START: 'action_start',
+        ACTION_COMPLETE: 'action_complete',
+        ACTION_ERROR: 'action_error',
+    },
+    worldModel: {
+        ENTITY_CHANGE: 'entity_change',
+        RELATION_CHANGE: 'relation_change',
+        PROPERTY_CHANGE: 'property_change',
+    },
+    textService: {
+        TEMPLATE_SELECTION: 'template_selection',
+        TEXT_GENERATION: 'text_generation',
+        CHANNEL_ROUTING: 'channel_routing',
+    },
+};
+//# sourceMappingURL=types.js.map

package/dist/debug/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/debug/types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAuCH;;GAEG;AACU,QAAA,eAAe,GAAG;IAC7B,MAAM,EAAE;QACN,cAAc,EAAE,gBAAgB;QAChC,aAAa,EAAE,eAAe;QAC9B,iBAAiB,EAAE,mBAAmB;KACvC;IACD,SAAS,EAAE;QACT,iBAAiB,EAAE,mBAAmB;QACtC,WAAW,EAAE,aAAa;QAC1B,oBAAoB,EAAE,sBAAsB;QAC5C,gBAAgB,EAAE,kBAAkB;KACrC;IACD,QAAQ,EAAE;QACR,YAAY,EAAE,cAAc;QAC5B,eAAe,EAAE,iBAAiB;QAClC,YAAY,EAAE,cAAc;KAC7B;IACD,UAAU,EAAE;QACV,aAAa,EAAE,eAAe;QAC9B,eAAe,EAAE,iBAAiB;QAClC,eAAe,EAAE,iBAAiB;KACnC;IACD,WAAW,EAAE;QACX,kBAAkB,EAAE,oBAAoB;QACxC,eAAe,EAAE,iBAAiB;QAClC,eAAe,EAAE,iBAAiB;KACnC;CACO,CAAC"}