@fabricorg/platform 0.9.0 → 0.11.0

package/dist/modules/index.d.ts

@@ -1,5 +1,7 @@
 import { ActionDefinition } from '../actions/index.js';
 import { DisplayRenderer } from '../displays/index.js';
+import { PortableJsonSchema, JsonValue } from '../objects/index.js';
+import { ViewContract } from '../projections/index.js';
 
 interface ModuleDependency {
     namespace: string;
@@ -23,6 +25,29 @@ interface ObjectTypeRegistration {
     displayName?: string;
     idPrefix?: string;
     isCoreModuleType?: boolean;
+    schema?: PortableJsonSchema;
+    semantics?: Record<string, JsonValue>;
+    relations?: ObjectRelationDefinition[];
+    invariants?: DeclarativeInvariant[];
+}
+type ObjectRelationCardinality = "one" | "many";
+type ObjectRelationSemantics = "reference" | "owned";
+type ObjectRelationDeleteBehavior = "restrict" | "cascade" | "set-null";
+interface ObjectRelationDefinition {
+    name: string;
+    target: `${string}.${string}`;
+    cardinality: ObjectRelationCardinality;
+    required?: boolean;
+    semantics: ObjectRelationSemantics;
+    onTargetDelete: ObjectRelationDeleteBehavior;
+}
+type InvariantEnforcement = "json-schema" | "state-machine" | "policy" | "host-adapter" | "application";
+interface DeclarativeInvariant {
+    id: string;
+    description: string;
+    required?: boolean;
+    enforcement: InvariantEnforcement;
+    enforcementRef?: string;
 }
 type ObjectTypeRegistrationInput = string | ObjectTypeRegistration;
 interface ModuleDisplayRendererRegistration {
@@ -38,11 +63,33 @@ interface StateMachineRegistration {
     entityType: string;
     states: string[];
 }
+interface CapabilitySlotDefinition {
+    name: string;
+    description: string;
+    shape?: PortableJsonSchema;
+}
+interface CapabilityMetadata {
+    displayName: string;
+    description: string;
+    roles?: string[];
+    stability: "experimental" | "beta" | "stable" | "deprecated";
+    deprecated?: {
+        since: string;
+        replacement?: string;
+        message: string;
+    };
+    slots?: CapabilitySlotDefinition[];
+    certification?: {
+        profile: string;
+        required: boolean;
+    };
+}
 interface FabricModule<TDb = unknown> {
     namespace: string;
     version?: string;
     displayName?: string;
     description?: string;
+    capability?: CapabilityMetadata;
     dependencies?: ModuleDependencyInput[];
     objectTypes?: ObjectTypeRegistrationInput[];
     subjectTypes?: string[];
@@ -59,6 +106,7 @@ interface FabricModule<TDb = unknown> {
     dataClassifications?: unknown[];
     retentionRules?: unknown[];
     evidenceRenderers?: unknown[];
+    views?: ViewContract[];
 }
 interface ModuleRegistry<TDb = unknown> {
     modules: ReadonlyMap<string, FabricModule<TDb>>;
@@ -71,4 +119,4 @@ declare function createModuleRegistry<TDb = unknown>(modules?: FabricModule<TDb>
 declare function registerFabricModule(module: FabricModule<unknown>): void;
 declare function registerFabricModules(modules: FabricModule<unknown>[]): FabricModule<unknown>[];
 
-export { type EventTypeRegistration, type EventTypeRegistrationInput, type FabricModule, type IdPrefixRegistration, type ModuleDependency, type ModuleDependencyInput, type ModuleDisplayRendererRegistration, type ModuleRegistry, type ObjectTypeRegistration, type ObjectTypeRegistrationInput, type PolicyRegistration, type StateMachineRegistration, createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace };
+export { type CapabilityMetadata, type CapabilitySlotDefinition, type DeclarativeInvariant, type EventTypeRegistration, type EventTypeRegistrationInput, type FabricModule, type IdPrefixRegistration, type InvariantEnforcement, type ModuleDependency, type ModuleDependencyInput, type ModuleDisplayRendererRegistration, type ModuleRegistry, type ObjectRelationCardinality, type ObjectRelationDefinition, type ObjectRelationDeleteBehavior, type ObjectRelationSemantics, type ObjectTypeRegistration, type ObjectTypeRegistrationInput, type PolicyRegistration, type StateMachineRegistration, createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace };

package/dist/modules/index.js

@@ -1,8 +1,9 @@
-export { createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace } from '../chunk-35DD3H55.js';
-import '../chunk-I35B576X.js';
+export { createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace } from '../chunk-3JQI3OFC.js';
+import '../chunk-3S6UTP4X.js';
 import '../chunk-6ER62UUN.js';
+import '../chunk-7WASIL46.js';
 import '../chunk-T2JLSZN6.js';
-import '../chunk-4SMPJPJ6.js';
+import '../chunk-JM55UQWK.js';
 import '../chunk-O5WVBQ7P.js';
 import '../chunk-4YQOGV7H.js';
 //# sourceMappingURL=index.js.map

package/dist/objects/index.cjs

@@ -1,24 +1,28 @@
 'use strict';
 
-var chunkQETQGAXJ_cjs = require('../chunk-QETQGAXJ.cjs');
+var chunkXCL2HBMB_cjs = require('../chunk-XCL2HBMB.cjs');
 
 
 
 Object.defineProperty(exports, "assertObjectType", {
   enumerable: true,
-  get: function () { return chunkQETQGAXJ_cjs.assertObjectType; }
+  get: function () { return chunkXCL2HBMB_cjs.assertObjectType; }
+});
+Object.defineProperty(exports, "assertPortableJsonSchema", {
+  enumerable: true,
+  get: function () { return chunkXCL2HBMB_cjs.assertPortableJsonSchema; }
 });
 Object.defineProperty(exports, "getRegisteredObjectTypes", {
   enumerable: true,
-  get: function () { return chunkQETQGAXJ_cjs.getRegisteredObjectTypes; }
+  get: function () { return chunkXCL2HBMB_cjs.getRegisteredObjectTypes; }
 });
 Object.defineProperty(exports, "isValidObjectType", {
   enumerable: true,
-  get: function () { return chunkQETQGAXJ_cjs.isValidObjectType; }
+  get: function () { return chunkXCL2HBMB_cjs.isValidObjectType; }
 });
 Object.defineProperty(exports, "registerObjectType", {
   enumerable: true,
-  get: function () { return chunkQETQGAXJ_cjs.registerObjectType; }
+  get: function () { return chunkXCL2HBMB_cjs.registerObjectType; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/objects/index.d.cts

@@ -1,7 +1,51 @@
 type FabricObjectType = string;
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Dependency-free JSON Schema profile accepted in portable module manifests.
+ * Unknown extension keywords must use an `x-` prefix. Runtime validators may
+ * support more vocabulary, but exported entity contracts stay in this profile.
+ */
+interface PortableJsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, PortableJsonSchema>;
+    title?: string;
+    description?: string;
+    type?: "null" | "boolean" | "object" | "array" | "number" | "integer" | "string" | Array<"null" | "boolean" | "object" | "array" | "number" | "integer" | "string">;
+    enum?: JsonValue[];
+    const?: JsonValue;
+    properties?: Record<string, PortableJsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | PortableJsonSchema;
+    items?: PortableJsonSchema | PortableJsonSchema[];
+    allOf?: PortableJsonSchema[];
+    anyOf?: PortableJsonSchema[];
+    oneOf?: PortableJsonSchema[];
+    not?: PortableJsonSchema;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    default?: JsonValue;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    [key: `x-${string}`]: JsonValue | undefined;
+}
+declare function assertPortableJsonSchema(schema: unknown, path?: string): asserts schema is PortableJsonSchema;
 declare function assertObjectType(type: string): asserts type is FabricObjectType;
 declare function registerObjectType(type: string): void;
 declare function isValidObjectType(type: string): boolean;
 declare function getRegisteredObjectTypes(): string[];
 
-export { type FabricObjectType, assertObjectType, getRegisteredObjectTypes, isValidObjectType, registerObjectType };
+export { type FabricObjectType, type JsonPrimitive, type JsonValue, type PortableJsonSchema, assertObjectType, assertPortableJsonSchema, getRegisteredObjectTypes, isValidObjectType, registerObjectType };

package/dist/objects/index.d.ts

@@ -1,7 +1,51 @@
 type FabricObjectType = string;
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Dependency-free JSON Schema profile accepted in portable module manifests.
+ * Unknown extension keywords must use an `x-` prefix. Runtime validators may
+ * support more vocabulary, but exported entity contracts stay in this profile.
+ */
+interface PortableJsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, PortableJsonSchema>;
+    title?: string;
+    description?: string;
+    type?: "null" | "boolean" | "object" | "array" | "number" | "integer" | "string" | Array<"null" | "boolean" | "object" | "array" | "number" | "integer" | "string">;
+    enum?: JsonValue[];
+    const?: JsonValue;
+    properties?: Record<string, PortableJsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | PortableJsonSchema;
+    items?: PortableJsonSchema | PortableJsonSchema[];
+    allOf?: PortableJsonSchema[];
+    anyOf?: PortableJsonSchema[];
+    oneOf?: PortableJsonSchema[];
+    not?: PortableJsonSchema;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    default?: JsonValue;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    [key: `x-${string}`]: JsonValue | undefined;
+}
+declare function assertPortableJsonSchema(schema: unknown, path?: string): asserts schema is PortableJsonSchema;
 declare function assertObjectType(type: string): asserts type is FabricObjectType;
 declare function registerObjectType(type: string): void;
 declare function isValidObjectType(type: string): boolean;
 declare function getRegisteredObjectTypes(): string[];
 
-export { type FabricObjectType, assertObjectType, getRegisteredObjectTypes, isValidObjectType, registerObjectType };
+export { type FabricObjectType, type JsonPrimitive, type JsonValue, type PortableJsonSchema, assertObjectType, assertPortableJsonSchema, getRegisteredObjectTypes, isValidObjectType, registerObjectType };

package/dist/objects/index.js

@@ -1,3 +1,3 @@
-export { assertObjectType, getRegisteredObjectTypes, isValidObjectType, registerObjectType } from '../chunk-I35B576X.js';
+export { assertObjectType, assertPortableJsonSchema, getRegisteredObjectTypes, isValidObjectType, registerObjectType } from '../chunk-3S6UTP4X.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/projections/index.cjs

@@ -1,12 +1,36 @@
 'use strict';
 
-var chunkQ3WYIWCN_cjs = require('../chunk-Q3WYIWCN.cjs');
+var chunkO7IHZ53Y_cjs = require('../chunk-O7IHZ53Y.cjs');
 
 
 
+Object.defineProperty(exports, "getRegisteredViewContractKeys", {
+  enumerable: true,
+  get: function () { return chunkO7IHZ53Y_cjs.getRegisteredViewContractKeys; }
+});
+Object.defineProperty(exports, "registerViewContract", {
+  enumerable: true,
+  get: function () { return chunkO7IHZ53Y_cjs.registerViewContract; }
+});
+Object.defineProperty(exports, "registerViewContractIfMissing", {
+  enumerable: true,
+  get: function () { return chunkO7IHZ53Y_cjs.registerViewContractIfMissing; }
+});
 Object.defineProperty(exports, "replayEvents", {
   enumerable: true,
-  get: function () { return chunkQ3WYIWCN_cjs.replayEvents; }
+  get: function () { return chunkO7IHZ53Y_cjs.replayEvents; }
+});
+Object.defineProperty(exports, "replayView", {
+  enumerable: true,
+  get: function () { return chunkO7IHZ53Y_cjs.replayView; }
+});
+Object.defineProperty(exports, "resolveViewContract", {
+  enumerable: true,
+  get: function () { return chunkO7IHZ53Y_cjs.resolveViewContract; }
+});
+Object.defineProperty(exports, "viewContractKey", {
+  enumerable: true,
+  get: function () { return chunkO7IHZ53Y_cjs.viewContractKey; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/projections/index.d.cts

@@ -1,8 +1,11 @@
+import { PortableJsonSchema } from '../objects/index.cjs';
+
 interface ReplayableAssetEvent<Payload = unknown> {
     id: string;
     tenantId: string;
     spaceId: string;
     eventType: string;
+    eventSchemaVersion?: number;
     subjectType: string;
     subjectId: string;
     payload: Payload;
@@ -12,6 +15,39 @@ interface ReplayableAssetEvent<Payload = unknown> {
     actionInvocationId: string;
     correlationId: string;
 }
+
+interface ViewEventConsumption {
+    eventType: string;
+    schemaVersions: number[];
+}
+interface ViewContract<State = unknown, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+    /** Stable module-qualified logical identity, for example `orders/summary`. */
+    name: `${string}/${string}`;
+    version: string;
+    shape: PortableJsonSchema;
+    consumes: ViewEventConsumption[];
+    scope: "tenant-space";
+    snapshotVersion: number;
+    compatibleSnapshotVersions?: number[];
+    /** Required to transform any older compatible snapshot into the current state shape. */
+    upgradeSnapshot?: (data: unknown, fromVersion: number) => State | Promise<State>;
+    initialState: State;
+    applyEvent: (state: State, event: Event) => State | Promise<State>;
+}
+declare function viewContractKey(view: Pick<ViewContract, "name" | "version">): string;
+declare function registerViewContract(view: ViewContract): void;
+declare function registerViewContractIfMissing(view: ViewContract): void;
+declare function resolveViewContract(name: string, version: string): ViewContract | undefined;
+declare function getRegisteredViewContractKeys(): string[];
+interface ReplayViewOptions<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+    view: ViewContract<State, Event>;
+    events: Iterable<Event> | AsyncIterable<Event>;
+    scope: ReplayScope;
+    snapshot?: (ReplaySnapshot<State> & {
+        snapshotVersion: number;
+    }) | null;
+}
+declare function replayView<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent>({ view, events, scope, snapshot, }: ReplayViewOptions<State, Event>): Promise<ReplayEventsResult<State, Event>>;
 interface ReplayScope {
     tenantId: string;
     spaceId: string;
@@ -23,7 +59,7 @@ interface ReplaySnapshot<State = unknown> {
     eventCursor?: string | null;
     eventSequence?: number | null;
 }
-type ReplayWarningCode = "cursor_not_found" | "duplicate_event" | "missing_sequence" | "subject_scope_incomplete";
+type ReplayWarningCode = "cursor_not_found" | "duplicate_event" | "missing_sequence" | "subject_scope_incomplete" | "unsupported_event_version";
 interface ReplayWarning {
     code: ReplayWarningCode;
     message: string;
@@ -49,4 +85,4 @@ interface ReplayEventsResult<State, Event extends ReplayableAssetEvent = Replaya
 }
 declare function replayEvents<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent>({ events, scope, initialState, snapshot, applyEvent, }: ReplayEventsOptions<State, Event>): Promise<ReplayEventsResult<State, Event>>;
 
-export { type ReplayEventsOptions, type ReplayEventsResult, type ReplayScope, type ReplaySnapshot, type ReplayWarning, type ReplayWarningCode, type ReplayableAssetEvent, replayEvents };
+export { type ReplayEventsOptions, type ReplayEventsResult, type ReplayScope, type ReplaySnapshot, type ReplayViewOptions, type ReplayWarning, type ReplayWarningCode, type ReplayableAssetEvent, type ViewContract, type ViewEventConsumption, getRegisteredViewContractKeys, registerViewContract, registerViewContractIfMissing, replayEvents, replayView, resolveViewContract, viewContractKey };

package/dist/projections/index.d.ts

@@ -1,8 +1,11 @@
+import { PortableJsonSchema } from '../objects/index.js';
+
 interface ReplayableAssetEvent<Payload = unknown> {
     id: string;
     tenantId: string;
     spaceId: string;
     eventType: string;
+    eventSchemaVersion?: number;
     subjectType: string;
     subjectId: string;
     payload: Payload;
@@ -12,6 +15,39 @@ interface ReplayableAssetEvent<Payload = unknown> {
     actionInvocationId: string;
     correlationId: string;
 }
+
+interface ViewEventConsumption {
+    eventType: string;
+    schemaVersions: number[];
+}
+interface ViewContract<State = unknown, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+    /** Stable module-qualified logical identity, for example `orders/summary`. */
+    name: `${string}/${string}`;
+    version: string;
+    shape: PortableJsonSchema;
+    consumes: ViewEventConsumption[];
+    scope: "tenant-space";
+    snapshotVersion: number;
+    compatibleSnapshotVersions?: number[];
+    /** Required to transform any older compatible snapshot into the current state shape. */
+    upgradeSnapshot?: (data: unknown, fromVersion: number) => State | Promise<State>;
+    initialState: State;
+    applyEvent: (state: State, event: Event) => State | Promise<State>;
+}
+declare function viewContractKey(view: Pick<ViewContract, "name" | "version">): string;
+declare function registerViewContract(view: ViewContract): void;
+declare function registerViewContractIfMissing(view: ViewContract): void;
+declare function resolveViewContract(name: string, version: string): ViewContract | undefined;
+declare function getRegisteredViewContractKeys(): string[];
+interface ReplayViewOptions<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+    view: ViewContract<State, Event>;
+    events: Iterable<Event> | AsyncIterable<Event>;
+    scope: ReplayScope;
+    snapshot?: (ReplaySnapshot<State> & {
+        snapshotVersion: number;
+    }) | null;
+}
+declare function replayView<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent>({ view, events, scope, snapshot, }: ReplayViewOptions<State, Event>): Promise<ReplayEventsResult<State, Event>>;
 interface ReplayScope {
     tenantId: string;
     spaceId: string;
@@ -23,7 +59,7 @@ interface ReplaySnapshot<State = unknown> {
     eventCursor?: string | null;
     eventSequence?: number | null;
 }
-type ReplayWarningCode = "cursor_not_found" | "duplicate_event" | "missing_sequence" | "subject_scope_incomplete";
+type ReplayWarningCode = "cursor_not_found" | "duplicate_event" | "missing_sequence" | "subject_scope_incomplete" | "unsupported_event_version";
 interface ReplayWarning {
     code: ReplayWarningCode;
     message: string;
@@ -49,4 +85,4 @@ interface ReplayEventsResult<State, Event extends ReplayableAssetEvent = Replaya
 }
 declare function replayEvents<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent>({ events, scope, initialState, snapshot, applyEvent, }: ReplayEventsOptions<State, Event>): Promise<ReplayEventsResult<State, Event>>;
 
-export { type ReplayEventsOptions, type ReplayEventsResult, type ReplayScope, type ReplaySnapshot, type ReplayWarning, type ReplayWarningCode, type ReplayableAssetEvent, replayEvents };
+export { type ReplayEventsOptions, type ReplayEventsResult, type ReplayScope, type ReplaySnapshot, type ReplayViewOptions, type ReplayWarning, type ReplayWarningCode, type ReplayableAssetEvent, type ViewContract, type ViewEventConsumption, getRegisteredViewContractKeys, registerViewContract, registerViewContractIfMissing, replayEvents, replayView, resolveViewContract, viewContractKey };

package/dist/projections/index.js

@@ -1,3 +1,3 @@
-export { replayEvents } from '../chunk-JSTGOT6P.js';
+export { getRegisteredViewContractKeys, registerViewContract, registerViewContractIfMissing, replayEvents, replayView, resolveViewContract, viewContractKey } from '../chunk-7WASIL46.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabricorg/platform",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Generic, vertical-agnostic runtime for ontology-based business applications. Provides actions, modules, events, policies, state machines, adapters, displays, projections, privacy, and evidence contracts. Zero runtime dependencies; portable across any database client and any vertical (lending, insurance, healthcare, legal, etc.).",
   "keywords": [
     "fabric",
@@ -118,6 +118,16 @@
         "default": "./dist/ids/index.cjs"
       }
     },
+    "./manifest": {
+      "import": {
+        "types": "./dist/manifest/index.d.ts",
+        "default": "./dist/manifest/index.js"
+      },
+      "require": {
+        "types": "./dist/manifest/index.d.cts",
+        "default": "./dist/manifest/index.cjs"
+      }
+    },
     "./modules": {
       "import": {
         "types": "./dist/modules/index.d.ts",

package/dist/chunk-35DD3H55.js

@@ -1,187 +0,0 @@
-import { registerObjectType } from './chunk-I35B576X.js';
-import { registerPolicyIfMissing } from './chunk-6ER62UUN.js';
-import { registerStateMachineIfMissing } from './chunk-T2JLSZN6.js';
-import { registerActionIfMissing } from './chunk-4SMPJPJ6.js';
-import { registerDisplayRenderer } from './chunk-O5WVBQ7P.js';
-import { registerSubjectType, registerEventType, isValidEventType } from './chunk-4YQOGV7H.js';
-
-// modules/index.ts
-var registeredModuleNamespaces = /* @__PURE__ */ new Set();
-function getModuleDependencyNamespace(dependency) {
-  return typeof dependency === "string" ? dependency : dependency.namespace;
-}
-function getObjectTypeName(objectType) {
-  return typeof objectType === "string" ? objectType : objectType.type;
-}
-function getEventTypeName(eventType) {
-  return typeof eventType === "string" ? eventType : eventType.eventType;
-}
-function validateModuleNamespace(namespace) {
-  if (!namespace) {
-    throw new Error("Module namespace cannot be empty");
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(namespace)) {
-    throw new Error(
-      `Invalid module namespace: "${namespace}". Must be lowercase letters, numbers, and hyphens only.`
-    );
-  }
-}
-function createModuleRegistry(modules = []) {
-  const registered = /* @__PURE__ */ new Map();
-  for (const module of modules) {
-    validateModuleNamespace(module.namespace);
-    if (registered.has(module.namespace)) {
-      throw new Error(`Duplicate FabricModule namespace "${module.namespace}".`);
-    }
-    registered.set(module.namespace, module);
-  }
-  return { modules: registered };
-}
-function validateIdentifierList(values, label, namespace) {
-  for (const value of values ?? []) {
-    if (!value) {
-      throw new Error(`Module "${namespace}" has an empty ${label} entry.`);
-    }
-  }
-}
-function validateManifest(module, context = {}) {
-  validateModuleNamespace(module.namespace);
-  const dependencies = (module.dependencies ?? []).map(getModuleDependencyNamespace);
-  const objectTypes = (module.objectTypes ?? []).map(getObjectTypeName);
-  const eventTypes = (module.eventTypes ?? []).map(getEventTypeName);
-  for (const dependency of dependencies) {
-    validateModuleNamespace(dependency);
-    if (dependency === module.namespace) {
-      throw new Error(`Module "${module.namespace}" cannot depend on itself.`);
-    }
-    if (context.availableNamespaces && !context.availableNamespaces.has(dependency)) {
-      throw new Error(`Module "${module.namespace}" depends on missing module "${dependency}".`);
-    }
-  }
-  validateIdentifierList(objectTypes, "objectTypes", module.namespace);
-  validateIdentifierList(module.subjectTypes, "subjectTypes", module.namespace);
-  validateIdentifierList(eventTypes, "eventTypes", module.namespace);
-  for (const objectType of objectTypes) {
-    if (!/^[A-Z][a-zA-Z0-9]*$/.test(objectType)) {
-      throw new Error(
-        `Invalid object type: "${objectType}". Object types must be PascalCase alphanumeric.`
-      );
-    }
-  }
-  for (const action of module.actions ?? []) {
-    if (!/^[a-z][a-z0-9-]*\.[a-z][a-z0-9_]*$/.test(action.actionId)) {
-      throw new Error(`Invalid action ID: ${action.actionId}`);
-    }
-    if (action.namespace !== module.namespace) {
-      throw new Error(
-        `Action "${action.actionId}" declares namespace "${action.namespace}" but is registered by module "${module.namespace}".`
-      );
-    }
-    if (!action.actionId.startsWith(`${module.namespace}.`)) {
-      throw new Error(
-        `Action "${action.actionId}" must start with module namespace "${module.namespace}."`
-      );
-    }
-    if (action.mutatesDomain && action.emitsEvents.length === 0) {
-      throw new Error(
-        `Action "${action.actionId}" mutates domain but emits no events. Every mutating action must emit at least one AssetEvent.`
-      );
-    }
-  }
-  for (const descriptor of module.displayRenderers ?? []) {
-    const isPlannedEventType = context.plannedEventTypes?.has(descriptor.eventType) ?? false;
-    const isModuleEventType = eventTypes.includes(descriptor.eventType);
-    if (!isValidEventType(descriptor.eventType) && !isModuleEventType && !isPlannedEventType) {
-      throw new Error(
-        `Display renderer registered for unknown event type "${descriptor.eventType}". Register the event type before adding a display renderer.`
-      );
-    }
-  }
-}
-function sortModulesByDependency(modules, registeredNamespaces = registeredModuleNamespaces) {
-  const modulesByNamespace = /* @__PURE__ */ new Map();
-  for (const module of modules) {
-    validateModuleNamespace(module.namespace);
-    if (modulesByNamespace.has(module.namespace)) {
-      throw new Error(`Duplicate Fabric module namespace "${module.namespace}".`);
-    }
-    modulesByNamespace.set(module.namespace, module);
-  }
-  const sorted = [];
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  function visit(module, path) {
-    if (visited.has(module.namespace)) {
-      return;
-    }
-    if (visiting.has(module.namespace)) {
-      throw new Error(
-        `Cyclic Fabric module dependency detected: ${[...path, module.namespace].join(" -> ")}`
-      );
-    }
-    visiting.add(module.namespace);
-    for (const dependency of (module.dependencies ?? []).map(getModuleDependencyNamespace)) {
-      const dependencyModule = modulesByNamespace.get(dependency);
-      if (!dependencyModule) {
-        if (registeredNamespaces.has(dependency)) {
-          continue;
-        }
-        throw new Error(`Module "${module.namespace}" depends on missing module "${dependency}".`);
-      }
-      visit(dependencyModule, [...path, module.namespace]);
-    }
-    visiting.delete(module.namespace);
-    visited.add(module.namespace);
-    sorted.push(module);
-  }
-  for (const module of modules) {
-    visit(module, []);
-  }
-  return sorted;
-}
-function registerFabricModule(module) {
-  validateManifest(module, { availableNamespaces: registeredModuleNamespaces });
-  for (const objectType of module.objectTypes ?? []) {
-    registerObjectType(getObjectTypeName(objectType));
-  }
-  for (const subjectType of module.subjectTypes ?? []) {
-    registerSubjectType(subjectType);
-  }
-  for (const eventType of module.eventTypes ?? []) {
-    registerEventType(getEventTypeName(eventType));
-  }
-  for (const policy of module.policies ?? []) {
-    registerPolicyIfMissing(policy);
-  }
-  for (const machine of module.stateMachines ?? []) {
-    registerStateMachineIfMissing(machine);
-  }
-  for (const action of module.actions ?? []) {
-    registerActionIfMissing(action);
-  }
-  for (const descriptor of module.displayRenderers ?? []) {
-    registerDisplayRenderer(descriptor.eventType, descriptor.renderer);
-  }
-  registeredModuleNamespaces.add(module.namespace);
-}
-function registerFabricModules(modules) {
-  const availableNamespaces = /* @__PURE__ */ new Set([
-    ...registeredModuleNamespaces,
-    ...modules.map((module) => module.namespace)
-  ]);
-  const plannedEventTypes = new Set(
-    modules.flatMap((module) => (module.eventTypes ?? []).map(getEventTypeName))
-  );
-  for (const module of modules) {
-    validateManifest(module, { availableNamespaces, plannedEventTypes });
-  }
-  const sortedModules = sortModulesByDependency(modules);
-  for (const module of sortedModules) {
-    registerFabricModule(module);
-  }
-  return sortedModules;
-}
-
-export { createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace };
-//# sourceMappingURL=chunk-35DD3H55.js.map
-//# sourceMappingURL=chunk-35DD3H55.js.map