@fabricorg/platform 1.9.0 → 1.10.1

package/dist/modules/index.d.ts

@@ -1,93 +1,92 @@
-import { ActionDefinition } from '../actions/index.js';
-import { JsonValue, PortableJsonSchema } from '../objects/index.js';
-import { PolicyId, PolicyEvaluator } from '../policies/index.js';
-import { StateMachineDefinition } from '../state-machines/index.js';
-import { ViewContract } from '../projections/index.js';
-import '../discovery/index.js';
-
-interface ModuleDependency {
-    namespace: string;
-    version?: string;
-    optional?: boolean;
-}
-type ModuleDependencyInput = string | ModuleDependency;
-interface IdPrefixRegistration {
-    prefix: string;
-    name: string;
-    module: string;
-}
-interface EventTypeRegistration {
-    eventType: string;
-    schemaVersion: number;
-    description?: string;
-    schema?: PortableJsonSchema;
-}
-type EventTypeRegistrationInput = string | EventTypeRegistration;
-interface ObjectTypeRegistration {
-    type: string;
-    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 {
+import { ActionDefinition } from "../actions/index.js";
+import { i as JsonValue, o as PortableJsonSchema } from "../index-DZ4mnNb7.js";
+import { C as PolicyId, _ as PolicyEvaluator } from "../index-sPUPs8pr.js";
+import { i as StateMachineDefinition } from "../index-fmUiRBXu.js";
+import { l as ViewContract } from "../index-IqcDvl69.js";
+//#region modules/index.d.ts
+export interface ModuleDependency {
+  namespace: string;
+  version?: string;
+  optional?: boolean;
+}
+export type ModuleDependencyInput = string | ModuleDependency;
+export interface IdPrefixRegistration {
+  prefix: string;
+  name: string;
+  module: string;
+}
+export interface EventTypeRegistration {
+  eventType: string;
+  schemaVersion: number;
+  description?: string;
+  schema?: PortableJsonSchema;
+}
+export type EventTypeRegistrationInput = string | EventTypeRegistration;
+export interface ObjectTypeRegistration {
+  type: string;
+  displayName?: string;
+  idPrefix?: string;
+  isCoreModuleType?: boolean;
+  schema?: PortableJsonSchema;
+  semantics?: Record<string, JsonValue>;
+  relations?: ObjectRelationDefinition[];
+  invariants?: DeclarativeInvariant[];
+}
+export type ObjectRelationCardinality = "one" | "many";
+export type ObjectRelationSemantics = "reference" | "owned";
+export type ObjectRelationDeleteBehavior = "restrict" | "cascade" | "set-null";
+export interface ObjectRelationDefinition {
+  name: string;
+  target: `${string}.${string}`;
+  cardinality: ObjectRelationCardinality;
+  required?: boolean;
+  semantics: ObjectRelationSemantics;
+  onTargetDelete: ObjectRelationDeleteBehavior;
+}
+export type InvariantEnforcement = "json-schema" | "state-machine" | "policy" | "host-adapter" | "application";
+export interface DeclarativeInvariant {
+  id: string;
+  description: string;
+  required?: boolean;
+  enforcement: InvariantEnforcement;
+  enforcementRef?: string;
+}
+export type ObjectTypeRegistrationInput = string | ObjectTypeRegistration;
+export interface PolicyRegistration {
+  id: string;
+  version?: string;
+  description?: string;
+}
+export interface StateMachineRegistration {
+  entityType: string;
+  states: string[];
+}
+export interface CapabilityPortRequirement {
+  name: string;
+  version?: string;
+  standard?: {
     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 PolicyRegistration {
-    id: string;
     version?: string;
-    description?: string;
-}
-interface StateMachineRegistration {
-    entityType: string;
-    states: string[];
-}
-interface CapabilityPortRequirement {
-    name: string;
-    version?: string;
-    standard?: {
-        name: string;
-        version?: string;
-    };
-}
-interface CapabilityRequirements {
-    ports?: CapabilityPortRequirement[];
-    permissions?: string[];
-    entitlements?: string[];
-    featureFlags?: string[];
-}
-interface CapabilityWorkflowTimer {
-    /** Workflow-local identity of the deadline, for example "right-to-cure". */
-    name: string;
-    /** Configuration key the duration is resolved from when the workflow starts. */
-    configKey: string;
-    description?: string;
-}
-interface CapabilityWorkflowCompensation {
-    /** Workflow step whose effect this reverses. */
-    step: string;
-    /** Governed action that performs the reversal. Must belong to the declaring module. */
-    actionId: `${string}.${string}`;
+  };
+}
+export interface CapabilityRequirements {
+  ports?: CapabilityPortRequirement[];
+  permissions?: string[];
+  entitlements?: string[];
+  featureFlags?: string[];
+}
+export interface CapabilityWorkflowTimer {
+  /** Workflow-local identity of the deadline, for example "right-to-cure". */
+  name: string;
+  /** Configuration key the duration is resolved from when the workflow starts. */
+  configKey: string;
+  description?: string;
+}
+export interface CapabilityWorkflowCompensation {
+  /** Workflow step whose effect this reverses. */
+  step: string;
+  /** Governed action that performs the reversal. Must belong to the declaring module. */
+  actionId: `${string}.${string}`;
 }
 /**
  * A durable workflow this capability owns. Declaring it makes durability a
@@ -95,76 +94,75 @@ interface CapabilityWorkflowCompensation {
  * the queue it runs on, the deadlines it carries, and what reverses each step
  * are all diffable.
  */
-interface CapabilityWorkflowDeclaration {
-    name: string;
-    /** Routing identity, conventionally `capability.vertical`. */
-    taskQueue: string;
-    /** Event type whose arrival starts this workflow by choreography. */
-    startedBy?: string;
-    timers?: CapabilityWorkflowTimer[];
-    compensations?: CapabilityWorkflowCompensation[];
-}
-interface CapabilityMetadata {
-    displayName: string;
-    description: string;
-    stability: "experimental" | "beta" | "stable" | "deprecated";
-    deprecated?: {
-        since: string;
-        replacement?: string;
-        message: string;
-    };
-    requirements?: CapabilityRequirements;
-    certification?: {
-        profile: string;
-        required: boolean;
-    };
-    /** Durable workflows this capability owns, with their queues, deadlines and reversals. */
-    workflows?: CapabilityWorkflowDeclaration[];
-    /** Namespaced declared data preserved by Platform and interpreted only by its owning package. */
-    extensions?: Record<string, JsonValue>;
-}
-interface FabricModule<TDb = unknown> {
-    namespace: string;
-    version?: string;
-    /** Compiler manifest digest for exact runtime assembly verification. */
-    manifestDigest?: string;
-    displayName?: string;
-    description?: string;
-    capability?: CapabilityMetadata;
-    dependencies?: ModuleDependencyInput[];
-    objectTypes?: ObjectTypeRegistrationInput[];
-    subjectTypes?: string[];
-    idPrefixes?: IdPrefixRegistration[];
-    eventTypes?: EventTypeRegistrationInput[];
-    actions?: ActionDefinition<TDb>[];
-    policies?: unknown[];
-    stateMachines?: unknown[];
-    adapterDefinitions?: unknown[];
-    permissions?: unknown[];
-    roles?: unknown[];
-    redactionRules?: unknown[];
-    dataClassifications?: unknown[];
-    retentionRules?: unknown[];
-    evidenceRenderers?: unknown[];
-    views?: ViewContract[];
-}
-interface ModuleRegistry<TDb = unknown> {
-    modules: ReadonlyMap<string, FabricModule<TDb>>;
-    orderedModules: readonly FabricModule<TDb>[];
-    resolveAction(actionId: `${string}.${string}`): ActionDefinition<TDb> | undefined;
-    resolvePolicy(policyId: PolicyId): PolicyEvaluator | undefined;
-    resolveStateMachine(entityType: string): StateMachineDefinition | undefined;
-    resolveView(name: string, version: string): ViewContract | undefined;
-}
-declare function getModuleDependencyNamespace(dependency: ModuleDependencyInput): string;
-declare function getObjectTypeName(objectType: ObjectTypeRegistrationInput): string;
-declare function getEventTypeName(eventType: EventTypeRegistrationInput): string;
-declare function validateModuleNamespace(namespace: string): void;
-declare function createModuleRegistry<TDb = unknown>(modules?: FabricModule<TDb>[]): ModuleRegistry<TDb>;
-declare function validateAndOrderFabricModules<TDb = unknown>(modules: FabricModule<TDb>[]): FabricModule<TDb>[];
+export interface CapabilityWorkflowDeclaration {
+  name: string;
+  /** Routing identity, conventionally `capability.vertical`. */
+  taskQueue: string;
+  /** Event type whose arrival starts this workflow by choreography. */
+  startedBy?: string;
+  timers?: CapabilityWorkflowTimer[];
+  compensations?: CapabilityWorkflowCompensation[];
+}
+export interface CapabilityMetadata {
+  displayName: string;
+  description: string;
+  stability: "experimental" | "beta" | "stable" | "deprecated";
+  deprecated?: {
+    since: string;
+    replacement?: string;
+    message: string;
+  };
+  requirements?: CapabilityRequirements;
+  certification?: {
+    profile: string;
+    required: boolean;
+  };
+  /** Durable workflows this capability owns, with their queues, deadlines and reversals. */
+  workflows?: CapabilityWorkflowDeclaration[];
+  /** Namespaced declared data preserved by Platform and interpreted only by its owning package. */
+  extensions?: Record<string, JsonValue>;
+}
+export interface FabricModule<TDb = unknown> {
+  namespace: string;
+  version?: string;
+  /** Compiler manifest digest for exact runtime assembly verification. */
+  manifestDigest?: string;
+  displayName?: string;
+  description?: string;
+  capability?: CapabilityMetadata;
+  dependencies?: ModuleDependencyInput[];
+  objectTypes?: ObjectTypeRegistrationInput[];
+  subjectTypes?: string[];
+  idPrefixes?: IdPrefixRegistration[];
+  eventTypes?: EventTypeRegistrationInput[];
+  actions?: ActionDefinition<TDb>[];
+  policies?: unknown[];
+  stateMachines?: unknown[];
+  adapterDefinitions?: unknown[];
+  permissions?: unknown[];
+  roles?: unknown[];
+  redactionRules?: unknown[];
+  dataClassifications?: unknown[];
+  retentionRules?: unknown[];
+  evidenceRenderers?: unknown[];
+  views?: ViewContract[];
+}
+export interface ModuleRegistry<TDb = unknown> {
+  modules: ReadonlyMap<string, FabricModule<TDb>>;
+  orderedModules: readonly FabricModule<TDb>[];
+  resolveAction(actionId: `${string}.${string}`): ActionDefinition<TDb> | undefined;
+  resolvePolicy(policyId: PolicyId): PolicyEvaluator | undefined;
+  resolveStateMachine(entityType: string): StateMachineDefinition | undefined;
+  resolveView(name: string, version: string): ViewContract | undefined;
+}
+export declare function getModuleDependencyNamespace(dependency: ModuleDependencyInput): string;
+export declare function getObjectTypeName(objectType: ObjectTypeRegistrationInput): string;
+export declare function getEventTypeName(eventType: EventTypeRegistrationInput): string;
+export declare function validateModuleNamespace(namespace: string): void;
+export declare function createModuleRegistry<TDb = unknown>(modules?: FabricModule<TDb>[]): ModuleRegistry<TDb>;
+export declare function validateAndOrderFabricModules<TDb = unknown>(modules: FabricModule<TDb>[]): FabricModule<TDb>[];
 /** @deprecated Use createModuleRegistry(); registration is now explicit and instance-scoped. */
-declare function registerFabricModules<TDb = unknown>(modules: FabricModule<TDb>[]): FabricModule<TDb>[];
+export declare function registerFabricModules<TDb = unknown>(modules: FabricModule<TDb>[]): FabricModule<TDb>[];
 /** @deprecated Use createModuleRegistry([module]); registration is now explicit and instance-scoped. */
-declare function registerFabricModule<TDb = unknown>(module: FabricModule<TDb>): void;
-
-export { type CapabilityMetadata, type CapabilityPortRequirement, type CapabilityRequirements, type CapabilityWorkflowCompensation, type CapabilityWorkflowDeclaration, type CapabilityWorkflowTimer, type DeclarativeInvariant, type EventTypeRegistration, type EventTypeRegistrationInput, type FabricModule, type IdPrefixRegistration, type InvariantEnforcement, type ModuleDependency, type ModuleDependencyInput, type ModuleRegistry, type ObjectRelationCardinality, type ObjectRelationDefinition, type ObjectRelationDeleteBehavior, type ObjectRelationSemantics, type ObjectTypeRegistration, type ObjectTypeRegistrationInput, type PolicyRegistration, type StateMachineRegistration, createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateAndOrderFabricModules, validateModuleNamespace };
+export declare function registerFabricModule<TDb = unknown>(module: FabricModule<TDb>): void;
+//#endregion

package/dist/modules/index.js

@@ -1,7 +1,275 @@
-export { createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateAndOrderFabricModules, validateModuleNamespace } from '../chunk-WNZP53GI.js';
-import '../chunk-ZAEVQSB5.js';
-import '../chunk-MLBALEUR.js';
-import '../chunk-LFE74IJX.js';
-import '../chunk-B5DOGDPG.js';
-//# sourceMappingURL=index.js.map
+import { createEventContractRegistry } from "../events/index.js";
+import { assertSurfaceDeclaration } from "../discovery/index.js";
+import { assertPortableJsonSchema } from "../objects/index.js";
+import { viewContractKey } from "../projections/index.js";
+//#region modules/index.ts
+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 orderedModules = validateAndOrderFabricModules(modules);
+	const registered = new Map(orderedModules.map((module) => [module.namespace, module]));
+	const actions = new Map(orderedModules.flatMap((module) => (module.actions ?? []).map((action) => [action.actionId, action])));
+	const policies = new Map(orderedModules.flatMap((module) => (module.policies ?? []).map((policy) => {
+		const evaluator = policy;
+		return [evaluator.policyId, evaluator];
+	})));
+	const machines = new Map(orderedModules.flatMap((module) => (module.stateMachines ?? []).map((machine) => {
+		const definition = machine;
+		return [definition.entityType, definition];
+	})));
+	const views = new Map(orderedModules.flatMap((module) => (module.views ?? []).map((view) => [viewContractKey(view), view])));
+	return {
+		modules: registered,
+		orderedModules,
+		resolveAction: (actionId) => actions.get(actionId),
+		resolvePolicy: (policyId) => policies.get(policyId),
+		resolveStateMachine: (entityType) => machines.get(entityType),
+		resolveView: (name, version) => views.get(`${name}@${version}`)
+	};
+}
+function validateIdentifierList(values, label, namespace) {
+	for (const value of values ?? []) if (!value) throw new Error(`Module "${namespace}" has an empty ${label} entry.`);
+}
+function assertJsonValue(value, path) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number" && Number.isFinite(value)) return;
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => assertJsonValue(item, `${path}[${index}]`));
+		return;
+	}
+	if (typeof value === "object") {
+		for (const [key, child] of Object.entries(value)) assertJsonValue(child, `${path}.${key}`);
+		return;
+	}
+	throw new Error(`${path} must contain JSON-serializable values.`);
+}
+function qualifiedObjectType(namespace, type) {
+	return `${namespace}.${type}`;
+}
+function validateObjectDefinition(objectType, namespace, context) {
+	if (typeof objectType === "string") return;
+	if (objectType.schema !== void 0) assertPortableJsonSchema(objectType.schema, `Module "${namespace}" object "${objectType.type}" schema`);
+	if (objectType.semantics !== void 0) assertJsonValue(objectType.semantics, `Module "${namespace}" object "${objectType.type}" semantics`);
+	const relationNames = /* @__PURE__ */ new Set();
+	for (const relation of objectType.relations ?? []) {
+		if (!/^[a-z][a-zA-Z0-9]*$/.test(relation.name)) throw new Error(`Module "${namespace}" object "${objectType.type}" has invalid relation name "${relation.name}".`);
+		if (relationNames.has(relation.name)) throw new Error(`Module "${namespace}" object "${objectType.type}" has duplicate relation "${relation.name}".`);
+		relationNames.add(relation.name);
+		if (!/^[a-z][a-z0-9-]*\.[A-Z][a-zA-Z0-9]*$/.test(relation.target)) throw new Error(`Relation "${relation.name}" target "${relation.target}" must be module-qualified.`);
+		if (context.availableObjectTypes && !context.availableObjectTypes.has(relation.target)) throw new Error(`Relation "${relation.name}" targets missing object type "${relation.target}".`);
+		if (relation.required && relation.onTargetDelete === "set-null") throw new Error(`Required relation "${relation.name}" cannot use onTargetDelete "set-null".`);
+	}
+	const invariantIds = /* @__PURE__ */ new Set();
+	for (const invariant of objectType.invariants ?? []) {
+		if (!invariant.id.trim() || !invariant.description.trim()) throw new Error(`Module "${namespace}" object "${objectType.type}" has an invariant without an id or description.`);
+		if (invariantIds.has(invariant.id)) throw new Error(`Module "${namespace}" object "${objectType.type}" has duplicate invariant "${invariant.id}".`);
+		invariantIds.add(invariant.id);
+		if (invariant.required && !invariant.enforcementRef?.trim()) throw new Error(`Required invariant "${invariant.id}" must declare enforcementRef.`);
+	}
+}
+function validateCapabilityWorkflows(module, context) {
+	const workflows = module.capability?.workflows ?? [];
+	const actionsById = new Map((module.actions ?? []).map((action) => [action.actionId, action]));
+	const names = /* @__PURE__ */ new Set();
+	for (const workflow of workflows) {
+		if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(workflow.name)) throw new Error(`Module "${module.namespace}" declares invalid workflow name "${workflow.name}".`);
+		if (names.has(workflow.name)) throw new Error(`Module "${module.namespace}" declares duplicate workflow "${workflow.name}".`);
+		names.add(workflow.name);
+		if (!/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/.test(workflow.taskQueue)) throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" declares invalid task queue "${workflow.taskQueue}".`);
+		if (workflow.startedBy !== void 0) {
+			if (!(context.plannedEventTypes?.has(workflow.startedBy) ?? (module.eventTypes ?? []).some((eventType) => getEventTypeName(eventType) === workflow.startedBy))) throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" is started by unknown event type "${workflow.startedBy}".`);
+		}
+		const timerNames = /* @__PURE__ */ new Set();
+		for (const timer of workflow.timers ?? []) {
+			if (!timer.name.trim() || !timer.configKey.trim()) throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" has a timer without a name or configKey.`);
+			if (timerNames.has(timer.name)) throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" declares duplicate timer "${timer.name}".`);
+			timerNames.add(timer.name);
+		}
+		const steps = /* @__PURE__ */ new Set();
+		for (const compensation of workflow.compensations ?? []) {
+			if (!compensation.step.trim()) throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" has a compensation without a step.`);
+			if (steps.has(compensation.step)) throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" declares duplicate compensation for step "${compensation.step}".`);
+			steps.add(compensation.step);
+			const compensatingAction = actionsById.get(compensation.actionId);
+			if (!compensatingAction) throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" compensates step "${compensation.step}" with unknown action "${compensation.actionId}".`);
+			if (!compensatingAction.idempotent || compensatingAction.execution?.idempotency === "prohibited") throw new Error(`Module "${module.namespace}" workflow "${workflow.name}" compensates step "${compensation.step}" with non-idempotent action "${compensation.actionId}"; a reversal must be safely repeatable.`);
+		}
+	}
+}
+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);
+	if (module.capability) {
+		if (!module.capability.displayName.trim() || !module.capability.description.trim()) throw new Error(`Module "${module.namespace}" capability requires displayName and description.`);
+		for (const namespace of Object.keys(module.capability.extensions ?? {})) if (!/^[a-z][a-z0-9.-]*\.[a-z0-9.-]+\/v[1-9][0-9]*$/.test(namespace)) throw new Error(`Module "${module.namespace}" capability has invalid extension namespace "${namespace}".`);
+		for (const port of module.capability.requirements?.ports ?? []) if (!/^[a-z][a-z0-9-]*(?:\.[a-z0-9-]+)*$/.test(port.name)) throw new Error(`Module "${module.namespace}" capability has invalid port requirement "${port.name}".`);
+		validateCapabilityWorkflows(module, context);
+	}
+	for (const eventType of module.eventTypes ?? []) if (typeof eventType !== "string" && eventType.schema) assertPortableJsonSchema(eventType.schema, `Event "${eventType.eventType}" schema`);
+	for (const action of module.actions ?? []) {
+		if (action.execution?.idempotency === "required" && !action.idempotent) throw new Error(`Action "${action.actionId}" requires idempotency but is not declared idempotent.`);
+		if (action.execution?.connectivity === "offline-capturable" && action.execution.idempotency === "prohibited") throw new Error(`Offline action "${action.actionId}" cannot prohibit idempotency.`);
+		if (action.execution?.completionDeadlineMs !== void 0 && !(typeof action.execution.completionDeadlineMs === "number" && action.execution.completionDeadlineMs > 0)) throw new Error(`Action "${action.actionId}" completionDeadlineMs must be a positive number of milliseconds.`);
+		if (action.execution?.completion === "immediate" && action.execution.completionDeadlineMs !== void 0) throw new Error(`Immediate action "${action.actionId}" cannot declare a completion deadline; nothing external completes it.`);
+	}
+	for (const view of module.views ?? []) if (view.usage?.collection?.filterSchema) assertPortableJsonSchema(view.usage.collection.filterSchema, `View "${view.name}" filter schema`);
+	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 objectType of module.objectTypes ?? []) {
+		if (typeof objectType !== "string") for (const relation of objectType.relations ?? []) {
+			const targetNamespace = relation.target.slice(0, relation.target.indexOf("."));
+			if (targetNamespace !== module.namespace && !dependencies.includes(targetNamespace)) throw new Error(`Module "${module.namespace}" relation "${relation.name}" targets module "${targetNamespace}" without declaring it as a dependency.`);
+		}
+		validateObjectDefinition(objectType, module.namespace, context);
+	}
+	for (const action of module.actions ?? []) {
+		assertSurfaceDeclaration(action, `Action "${action?.actionId ?? "unknown"}"`);
+		let parameterSchema;
+		try {
+			parameterSchema = action.schema.toJSONSchema?.();
+		} catch {
+			parameterSchema = void 0;
+		}
+		if (parameterSchema !== void 0) assertPortableJsonSchema(parameterSchema, `Action "${action.actionId}" parameters`);
+		let resultSchema;
+		try {
+			resultSchema = action.resultSchema?.toJSONSchema?.();
+		} catch {
+			resultSchema = void 0;
+		}
+		if (resultSchema !== void 0) assertPortableJsonSchema(resultSchema, `Action "${action.actionId}" result`);
+		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.`);
+		if (action.admitSubmission !== void 0 && typeof action.admitSubmission !== "function") throw new Error(`Action "${action.actionId}" declares admitSubmission that is not a function.`);
+	}
+	const viewKeys = /* @__PURE__ */ new Set();
+	for (const view of module.views ?? []) {
+		assertSurfaceDeclaration(view, `View "${view?.name ?? "unknown"}"`);
+		if (!view.name.startsWith(`${module.namespace}/`) || !/^[a-z][a-z0-9-]*\/[a-z][a-z0-9/_-]*$/.test(view.name)) throw new Error(`View "${view.name}" must start with module namespace "${module.namespace}/" and use lowercase path segments.`);
+		if (!view.version.trim()) throw new Error(`View "${view.name}" must declare a version.`);
+		const key = `${view.name}@${view.version}`;
+		if (viewKeys.has(key)) throw new Error(`Module "${module.namespace}" has duplicate view contract "${key}".`);
+		viewKeys.add(key);
+		assertPortableJsonSchema(view.shape, `View "${key}" shape`);
+		if (view.parameterSchema !== void 0) assertPortableJsonSchema(view.parameterSchema, `View "${key}" parameters`);
+		if (!Number.isInteger(view.snapshotVersion) || view.snapshotVersion < 1) throw new Error(`View "${key}" snapshotVersion must be a positive integer.`);
+		if ((view.compatibleSnapshotVersions?.some((version) => version !== view.snapshotVersion) ?? false) && !view.upgradeSnapshot) throw new Error(`View "${key}" declares older compatible snapshots but no upgradeSnapshot function.`);
+		for (const consumption of view.consumes) {
+			const isPlanned = context.plannedEventTypes?.has(consumption.eventType) ?? false;
+			const isModuleEvent = eventTypes.includes(consumption.eventType);
+			if (!isPlanned && !isModuleEvent) throw new Error(`View "${key}" consumes unknown event type "${consumption.eventType}".`);
+			if (consumption.schemaVersions.length === 0 || consumption.schemaVersions.some((version) => !Number.isInteger(version) || version < 1)) throw new Error(`View "${key}" must declare positive consumed schema versions for "${consumption.eventType}".`);
+		}
+	}
+}
+function sortModulesByDependency(modules, registeredNamespaces = /* @__PURE__ */ new Set()) {
+	const modulesByNamespace = /* @__PURE__ */ new Map();
+	for (const module of modules) {
+		validateModuleNamespace(module.namespace);
+		if (modulesByNamespace.has(module.namespace)) throw new Error(`Duplicate FabricModule 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 assertAcyclicRelations(modules) {
+	const relationKinds = [
+		{
+			label: "owned containment",
+			include: (relation) => relation.semantics === "owned"
+		},
+		{
+			label: "cascade-delete",
+			include: (relation) => relation.onTargetDelete === "cascade"
+		},
+		{
+			label: "required-construction",
+			include: (relation) => relation.required === true
+		}
+	];
+	for (const kind of relationKinds) {
+		const edges = /* @__PURE__ */ new Map();
+		for (const module of modules) for (const objectType of module.objectTypes ?? []) {
+			if (typeof objectType === "string") continue;
+			const source = qualifiedObjectType(module.namespace, objectType.type);
+			edges.set(source, (objectType.relations ?? []).filter(kind.include).map((relation) => relation.target));
+		}
+		const visiting = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (node, path) => {
+			if (visiting.has(node)) throw new Error(`${kind.label} relation cycle detected: ${[...path, node].join(" -> ")}`);
+			if (visited.has(node)) return;
+			visiting.add(node);
+			for (const target of edges.get(node) ?? []) visit(target, [...path, node]);
+			visiting.delete(node);
+			visited.add(node);
+		};
+		for (const node of edges.keys()) visit(node, []);
+	}
+}
+function validateAndOrderFabricModules(modules) {
+	const availableNamespaces = new Set(modules.map((module) => module.namespace));
+	const plannedEventTypes = new Set(modules.flatMap((module) => (module.eventTypes ?? []).map(getEventTypeName)));
+	for (const eventType of createEventContractRegistry().eventTypes()) plannedEventTypes.add(eventType);
+	const availableObjectTypes = /* @__PURE__ */ new Set([...modules.flatMap((module) => (module.objectTypes ?? []).map((objectType) => qualifiedObjectType(module.namespace, getObjectTypeName(objectType))))]);
+	for (const module of modules) validateManifest(module, {
+		availableNamespaces,
+		plannedEventTypes,
+		availableObjectTypes
+	});
+	assertAcyclicRelations(modules);
+	return sortModulesByDependency(modules);
+}
+/** @deprecated Use createModuleRegistry(); registration is now explicit and instance-scoped. */
+function registerFabricModules(modules) {
+	return validateAndOrderFabricModules(modules);
+}
+/** @deprecated Use createModuleRegistry([module]); registration is now explicit and instance-scoped. */
+function registerFabricModule(module) {
+	validateAndOrderFabricModules([module]);
+}
+//#endregion
+export { createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateAndOrderFabricModules, validateModuleNamespace };
+
 //# sourceMappingURL=index.js.map