ark-runtime-kernel 1.0.0 → 1.1.0

package/dist/nestjs/index.js

@@ -0,0 +1,2298 @@
+import { Module, Inject } from '@nestjs/common';
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+
+// src/kernel/audit/AuditTrail.ts
+var auditSequence = 0;
+function createAuditId() {
+  auditSequence += 1;
+  return `audit-${Date.now()}-${auditSequence}`;
+}
+function matchesQuery(record, query) {
+  if (query.type && record.type !== query.type) return false;
+  if (query.intent && record.intent !== query.intent) return false;
+  if (query.correlationId && record.correlationId !== query.correlationId) return false;
+  if (query.subject && record.subject !== query.subject) return false;
+  if (query.since && record.timestamp < query.since) return false;
+  if (query.until && record.timestamp > query.until) return false;
+  return true;
+}
+var InMemoryAuditStore = class {
+  constructor(maxRecords) {
+    this.maxRecords = maxRecords;
+  }
+  maxRecords;
+  records = [];
+  append(record) {
+    this.records.push(record);
+    if (this.maxRecords !== void 0 && this.records.length > this.maxRecords) {
+      this.records.splice(0, this.records.length - this.maxRecords);
+    }
+  }
+  query(query = {}) {
+    const records = this.records.filter((record) => matchesQuery(record, query));
+    return query.limit === void 0 ? [...records] : records.slice(-query.limit);
+  }
+  clear() {
+    this.records.length = 0;
+  }
+};
+var AuditTrailImpl = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async record(input) {
+    const record = {
+      id: createAuditId(),
+      timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      type: input.type,
+      source: input.source,
+      actor: input.actor,
+      intent: input.intent,
+      correlationId: input.correlationId,
+      causationId: input.causationId,
+      subject: input.subject,
+      details: input.details
+    };
+    await this.store.append(record);
+    return record;
+  }
+  async query(query) {
+    return this.store.query(query);
+  }
+  async clear() {
+    await this.store.clear();
+  }
+};
+function createAuditTrail(options = {}) {
+  return new AuditTrailImpl(
+    options.store ?? new InMemoryAuditStore(options.maxRecords)
+  );
+}
+
+// src/kernel/intent/validateIntentName.ts
+var ALLOWED_PREFIXES = [
+  "Domain.",
+  "Application.",
+  "Adapter.",
+  "Workflow.",
+  "Job.",
+  "Presentation.",
+  "Reporting.",
+  "Metadata.",
+  "Security.",
+  "Audit.",
+  "Observability.",
+  "Kernel."
+];
+function validateIntentName(name) {
+  if (!name || typeof name !== "string") {
+    return { valid: false, reason: "Intent name must be a non-empty string" };
+  }
+  if (!ALLOWED_PREFIXES.some((p) => name.startsWith(p))) {
+    return {
+      valid: false,
+      reason: `Intent "${name}" must start with one of: ${ALLOWED_PREFIXES.join(", ")}`
+    };
+  }
+  const rest = name.slice(name.indexOf(".") + 1);
+  if (!rest || !/^[A-Za-z][A-Za-z0-9_.]*$/.test(rest)) {
+    return {
+      valid: false,
+      reason: `Intent "${name}" has an invalid segment after the layer prefix`
+    };
+  }
+  return { valid: true };
+}
+
+// src/kernel/policy/PolicyViolationError.ts
+var PolicyViolationError = class extends Error {
+  violations;
+  constructor(violations) {
+    const messages = violations.map((v) => `- ${v.policyName}: ${v.message}`).join("\n");
+    super(`Hard policy violation(s) detected:
+${messages}`);
+    this.name = "PolicyViolationError";
+    this.violations = violations;
+  }
+};
+
+// src/kernel/policy/PolicyEngine.ts
+var PolicyEngine = class {
+  policies = [];
+  constructor(initialPolicies = []) {
+    for (const policy of initialPolicies) {
+      this.add(policy);
+    }
+  }
+  /**
+   * Adds a policy to the engine.
+   */
+  add(policy) {
+    if (this.policies.some((p) => p.name === policy.name)) {
+      throw new Error(`Policy "${policy.name}" is already registered in this engine.`);
+    }
+    this.policies.push(policy);
+  }
+  /**
+   * Returns all registered policies.
+   */
+  getPolicies() {
+    return [...this.policies];
+  }
+  /**
+   * Evaluates all policies against the provided context.
+   */
+  evaluate(context) {
+    const violations = [];
+    for (const policy of this.policies) {
+      const result = policy.check(context);
+      if (result === true) {
+        continue;
+      }
+      if (result === false) {
+        violations.push({
+          policyName: policy.name,
+          severity: policy.severity,
+          message: `Policy "${policy.name}" was violated.`
+        });
+        continue;
+      }
+      if (Array.isArray(result)) {
+        for (const v of result) {
+          violations.push({
+            policyName: policy.name,
+            severity: policy.severity,
+            message: v.message,
+            details: v.details
+          });
+        }
+      } else {
+        violations.push({
+          policyName: policy.name,
+          severity: policy.severity,
+          message: result.message,
+          details: result.details
+        });
+      }
+    }
+    const hardViolations = violations.filter((v) => v.severity === "hard");
+    const softViolations = violations.filter((v) => v.severity === "soft");
+    return {
+      passed: violations.length === 0,
+      violations,
+      hardViolations,
+      softViolations
+    };
+  }
+  /**
+   * Enforces all policies.
+   *
+   * - Soft violations are collected and can be observed (returned or logged).
+   * - Hard violations cause an error to be thrown (by default).
+   *
+   * @returns Evaluation result (including any soft violations)
+   * @throws Error if any hard policy is violated
+   */
+  enforce(context) {
+    const result = this.evaluate(context);
+    if (result.hardViolations.length > 0) {
+      throw new PolicyViolationError(result.hardViolations);
+    }
+    return result;
+  }
+  /**
+   * Clears all registered policies.
+   */
+  clear() {
+    this.policies.length = 0;
+  }
+};
+
+// src/kernel/policy/definePolicy.ts
+function definePolicy(options) {
+  const severity = options.severity ?? "soft";
+  const policy = {
+    name: options.name,
+    severity,
+    tags: options.tags,
+    owner: options.owner,
+    version: options.version,
+    rationale: options.rationale,
+    enforcementMode: options.enforcementMode,
+    deprecated: options.deprecated,
+    replacedBy: options.replacedBy,
+    check: options.check
+  };
+  return policy;
+}
+
+// src/kernel/policy/builtins.ts
+function defaultLayerOf(name) {
+  const dot = name.indexOf(".");
+  return dot >= 0 ? name.slice(0, dot) : name;
+}
+function resolveLayer(name, options) {
+  return options.resolveLayer?.(name) ?? defaultLayerOf(name);
+}
+function matchesRule(fromLayer, toLayer, rule) {
+  return fromLayer === rule.from && toLayer === rule.to;
+}
+function defineLayerPolicy(options) {
+  const name = options.name ?? "Layer isolation";
+  const severity = options.severity ?? "hard";
+  return definePolicy({
+    name,
+    severity,
+    tags: ["layer"],
+    check: (ctx) => {
+      const edges = [
+        ...(ctx.edges ?? []).filter((e) => e.kind === "declared" || e.kind === "produces").map((e) => ({ from: e.from, to: e.to })),
+        ...(ctx.relationships ?? []).filter((r) => r.kind === "dependsOn").map((r) => ({ from: r.from, to: r.to }))
+      ];
+      const violations = [];
+      for (const edge of edges) {
+        const fromLayer = resolveLayer(edge.from, options);
+        const toLayer = resolveLayer(edge.to, options);
+        for (const rule of options.rules) {
+          if (!rule.allowed && matchesRule(fromLayer, toLayer, rule)) {
+            violations.push({
+              policyName: name,
+              severity,
+              message: rule.message ?? `Layer violation: ${edge.from} (${fromLayer}) must not relate to ${edge.to} (${toLayer})`
+            });
+          }
+        }
+      }
+      return violations.length > 0 ? violations : true;
+    }
+  });
+}
+function isLayerPolicy(policy) {
+  return policy.tags?.includes("layer") ?? false;
+}
+function defineArchitectureProfilePolicy(profile, options = {}) {
+  return defineLayerPolicy({
+    name: options.name ?? `${profile.name} layer policy`,
+    severity: options.severity ?? "hard",
+    rules: profile.rules,
+    resolveLayer: profile.resolveLayer
+  });
+}
+
+// src/kernel/event-bus/policyContext.ts
+function buildPublishPolicyContext(options) {
+  return (event) => ({
+    event,
+    relationships: options.intentRegistry?.getAllRelationships(),
+    edges: options.dependencyGraph?.getEdges()
+  });
+}
+
+// src/kernel/event-bus/errors.ts
+var UnregisteredIntentError = class extends Error {
+  intentName;
+  constructor(intentName) {
+    super(
+      `Intent "${intentName}" is not registered. Register it with IntentRegistry.define() before publish/subscribe, including metadata.source producer intents in strict mode.`
+    );
+    this.name = "UnregisteredIntentError";
+    this.intentName = intentName;
+  }
+};
+var InvalidIntentNameError = class extends Error {
+  intentName;
+  reason;
+  constructor(intentName, reason) {
+    super(`Invalid intent name "${intentName}": ${reason}`);
+    this.name = "InvalidIntentNameError";
+    this.intentName = intentName;
+    this.reason = reason;
+  }
+};
+var LayerPolicyContextError = class extends Error {
+  constructor() {
+    super(
+      "Layer/architecture policies require intentRegistry, dependencyGraph, or a custom getPolicyContext. Without graph/registry context, layer policies cannot inspect relationships."
+    );
+    this.name = "LayerPolicyContextError";
+  }
+};
+var EventContractViolationError = class extends Error {
+  intentName;
+  issues;
+  constructor(intentName, issues) {
+    super(
+      `Event contract violation for "${intentName}". Register a matching event contract/version or fix the payload before publishing.`
+    );
+    this.name = "EventContractViolationError";
+    this.intentName = intentName;
+    this.issues = issues;
+  }
+};
+var UnknownEventSourceError = class extends Error {
+  intentName;
+  source;
+  constructor(intentName, source) {
+    super(
+      source ? `Event "${intentName}" metadata.source "${source}" is not registered. Register the producer intent or publish from a known source.` : `Event "${intentName}" must include metadata.source. Strict Ark uses source to enforce observed layer flow.`
+    );
+    this.name = "UnknownEventSourceError";
+    this.intentName = intentName;
+    this.source = source;
+  }
+};
+var SourceMetadataOverrideError = class extends Error {
+  boundSource;
+  attemptedSource;
+  constructor(boundSource, attemptedSource) {
+    super(
+      `Source-bound publisher for "${boundSource}" cannot publish with metadata.source "${attemptedSource}". Create a publisher for the intended source instead.`
+    );
+    this.name = "SourceMetadataOverrideError";
+    this.boundSource = boundSource;
+    this.attemptedSource = attemptedSource;
+  }
+};
+var ObservedLayerFlowViolationError = class extends Error {
+  source;
+  intentName;
+  fromLayer;
+  toLayer;
+  constructor(source, intentName, fromLayer, toLayer, message) {
+    super(
+      message ?? `Observed layer violation: "${source}" (${fromLayer}) must not produce "${intentName}" (${toLayer}). Route this through an allowed layer or adjust the architecture profile rule.`
+    );
+    this.name = "ObservedLayerFlowViolationError";
+    this.source = source;
+    this.intentName = intentName;
+    this.fromLayer = fromLayer;
+    this.toLayer = toLayer;
+  }
+};
+
+// src/kernel/event-bus/EventBus.ts
+var interceptorSequence = 0;
+function nextInterceptorRegistrationId() {
+  interceptorSequence += 1;
+  return `interceptor-${Date.now()}-${interceptorSequence}`;
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function clonePatchValue(value) {
+  if (Array.isArray(value)) return value.map(clonePatchValue);
+  if (isPlainRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [key, clonePatchValue(child)])
+    );
+  }
+  return value;
+}
+function mergeRecordPatch(target, patch, path = "payload") {
+  const next = { ...target };
+  for (const [key, value] of Object.entries(patch)) {
+    const childPath = `${path}.${key}`;
+    if (!(key in next) || next[key] === void 0) {
+      next[key] = clonePatchValue(value);
+      continue;
+    }
+    if (isPlainRecord(next[key]) && isPlainRecord(value)) {
+      next[key] = mergeRecordPatch(next[key], value, childPath);
+      continue;
+    }
+    if (Array.isArray(next[key]) && Array.isArray(value)) {
+      next[key] = mergeArrayPatch(next[key], value, childPath);
+      continue;
+    }
+    throw new Error(`Interceptor patch cannot overwrite existing ${childPath}.`);
+  }
+  return next;
+}
+function mergeArrayPatch(target, patch, path = "payload") {
+  const next = [...target];
+  patch.forEach((value, index) => {
+    const childPath = `${path}[${index}]`;
+    if (index >= next.length || next[index] === void 0) {
+      next[index] = clonePatchValue(value);
+      return;
+    }
+    if (isPlainRecord(next[index]) && isPlainRecord(value)) {
+      next[index] = mergeRecordPatch(next[index], value, childPath);
+      return;
+    }
+    if (Array.isArray(next[index]) && Array.isArray(value)) {
+      next[index] = mergeArrayPatch(next[index], value, childPath);
+      return;
+    }
+    throw new Error(`Interceptor patch cannot overwrite existing ${childPath}.`);
+  });
+  return next;
+}
+function applyPayloadPatch(payload, patch) {
+  if (Array.isArray(patch)) {
+    if (payload === void 0) return clonePatchValue(patch);
+    if (!Array.isArray(payload)) {
+      throw new Error("Array interceptor patch requires an array payload.");
+    }
+    return mergeArrayPatch(payload, patch);
+  }
+  if (payload === void 0) return clonePatchValue(patch);
+  if (!isPlainRecord(payload)) {
+    throw new Error("Object interceptor patch requires an object payload.");
+  }
+  return mergeRecordPatch(payload, patch);
+}
+var EventBusImpl = class {
+  subscriptions = [];
+  subscriptionsByIntent = /* @__PURE__ */ new Map();
+  interceptors = [];
+  interceptorsByIntent = /* @__PURE__ */ new Map();
+  history = [];
+  trace = [];
+  onPublish;
+  onSoftViolation;
+  onHandlerError;
+  auditTrail;
+  eventContracts;
+  strictEventContracts;
+  requireKnownSource;
+  architectureProfile;
+  enforceObservedLayerFlowMode;
+  outbox;
+  instanceId;
+  traceSinks;
+  rethrowHandlerErrors;
+  policyEngine;
+  getPolicyContext;
+  maxHistorySize;
+  intentRegistry;
+  dependencyGraph;
+  strictRegistry;
+  validateIntentNaming;
+  constructor(options = {}) {
+    this.onPublish = options.onPublish;
+    this.onSoftViolation = options.onSoftViolation;
+    this.onHandlerError = options.onHandlerError;
+    this.auditTrail = options.auditTrail;
+    this.eventContracts = options.eventContracts;
+    this.strictEventContracts = options.strictEventContracts ?? false;
+    this.requireKnownSource = options.requireKnownSource ?? false;
+    this.architectureProfile = options.architectureProfile;
+    this.enforceObservedLayerFlowMode = options.enforceObservedLayerFlow ?? "off";
+    this.outbox = options.outbox;
+    this.instanceId = options.instanceId;
+    this.traceSinks = [...options.traceSinks ?? []];
+    this.rethrowHandlerErrors = options.rethrowHandlerErrors ?? false;
+    this.maxHistorySize = options.maxHistorySize;
+    this.intentRegistry = options.intentRegistry;
+    this.dependencyGraph = options.dependencyGraph;
+    this.strictRegistry = options.strictRegistry ?? options.intentRegistry !== void 0;
+    this.validateIntentNaming = options.validateIntentNaming ?? this.strictRegistry;
+    if (options.policyEngine) {
+      this.policyEngine = options.policyEngine;
+    } else if (options.policies && options.policies.length > 0) {
+      this.policyEngine = new PolicyEngine(options.policies);
+    }
+    const allPolicies = this.policyEngine?.getPolicies() ?? options.policies ?? [];
+    if (allPolicies.some(isLayerPolicy) && !options.intentRegistry && !options.dependencyGraph && !options.getPolicyContext) {
+      throw new LayerPolicyContextError();
+    }
+    if (options.getPolicyContext) {
+      this.getPolicyContext = options.getPolicyContext;
+    } else if (options.intentRegistry || options.dependencyGraph) {
+      this.getPolicyContext = buildPublishPolicyContext({
+        intentRegistry: options.intentRegistry,
+        dependencyGraph: options.dependencyGraph
+      });
+    } else {
+      this.getPolicyContext = (event) => ({ event });
+    }
+  }
+  async publish(eventOrCreator, payloadOrMeta, metadata) {
+    let event;
+    const rawPublish = typeof eventOrCreator !== "function";
+    if (!rawPublish) {
+      const creator = eventOrCreator;
+      const payload = payloadOrMeta;
+      const extraMeta = metadata ?? {};
+      const created = creator(payload);
+      event = {
+        ...created,
+        metadata: this.enrichMetadata(created.metadata, extraMeta)
+      };
+    } else {
+      const rawEvent = eventOrCreator;
+      const extraMeta = metadata ?? payloadOrMeta ?? {};
+      event = {
+        ...rawEvent,
+        metadata: this.enrichMetadata(rawEvent.metadata, extraMeta)
+      };
+    }
+    if (rawPublish && this.strictRegistry) {
+      await this.recordRawPublishDiagnostic(event);
+    }
+    this.assertIntentAllowed(event.intent);
+    this.assertSourceAllowed(event);
+    this.assertContractAllowed(event);
+    event = await this.applyInterceptors(event);
+    this.assertContractAllowed(event);
+    await this.assertObservedLayerFlowAllowed(event);
+    this.dependencyGraph?.registerEventFlow(event.metadata.source, event.intent);
+    const matching = [...this.subscriptionsByIntent.get(event.intent) ?? []];
+    if (this.policyEngine) {
+      const ctx = this.getPolicyContext(event);
+      let policyResult;
+      try {
+        policyResult = this.policyEngine.enforce(ctx);
+      } catch (err) {
+        if (err instanceof PolicyViolationError) {
+          this.appendTrace({
+            type: "policy.hardViolation",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            intent: event.intent,
+            correlationId: event.metadata.correlationId,
+            traceId: event.metadata.traceId,
+            spanId: event.metadata.spanId,
+            details: { violations: err.violations }
+          });
+          await this.recordAudit("policy.hardViolation", event, {
+            violations: err.violations
+          });
+        }
+        throw err;
+      }
+      if (policyResult.softViolations.length > 0) {
+        this.appendTrace({
+          type: "policy.softViolation",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          intent: event.intent,
+          correlationId: event.metadata.correlationId,
+          traceId: event.metadata.traceId,
+          spanId: event.metadata.spanId,
+          details: { violations: policyResult.softViolations }
+        });
+        await this.recordAudit("policy.softViolation", event, {
+          violations: policyResult.softViolations
+        });
+        if (this.onSoftViolation) {
+          await this.safeHook(
+            () => this.onSoftViolation(policyResult, event),
+            "onSoftViolation",
+            event
+          );
+        }
+      }
+    }
+    const record = {
+      event,
+      publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      subscribersNotified: matching.length
+    };
+    this.appendHistory(record);
+    await this.outbox?.enqueue(event);
+    this.appendTrace({
+      type: "event.published",
+      timestamp: record.publishedAt,
+      intent: event.intent,
+      correlationId: event.metadata.correlationId,
+      traceId: event.metadata.traceId,
+      spanId: event.metadata.spanId,
+      details: { subscribersNotified: matching.length }
+    });
+    await this.recordAudit("event.published", event, {
+      subscribersNotified: matching.length
+    });
+    const notifications = matching.map(
+      (sub) => this.invokeHandler(sub, event)
+    );
+    await Promise.all(notifications);
+    if (this.onPublish) {
+      await this.safeHook(
+        () => this.onPublish(event),
+        "onPublish",
+        event
+      );
+    }
+  }
+  createPublisher(source) {
+    const sourceName = typeof source === "string" ? source : source.name;
+    this.assertIntentAllowed(sourceName);
+    return {
+      source: sourceName,
+      publish: async (intent, payload, metadata = {}) => {
+        if (metadata.source && metadata.source !== sourceName) {
+          throw new SourceMetadataOverrideError(sourceName, metadata.source);
+        }
+        await this.publish(intent, payload, {
+          ...metadata,
+          source: sourceName
+        });
+      }
+    };
+  }
+  subscribe(intent, handler) {
+    const intentName = typeof intent === "string" ? intent : intent.name;
+    this.assertIntentAllowed(intentName);
+    const sub = {
+      intentName,
+      handler
+    };
+    this.subscriptions.push(sub);
+    const subscriptionsForIntent = this.subscriptionsByIntent.get(intentName) ?? [];
+    subscriptionsForIntent.push(sub);
+    this.subscriptionsByIntent.set(intentName, subscriptionsForIntent);
+    return () => {
+      const idx = this.subscriptions.indexOf(sub);
+      if (idx >= 0) this.subscriptions.splice(idx, 1);
+      const byIntent = this.subscriptionsByIntent.get(intentName);
+      if (!byIntent) return;
+      const intentIdx = byIntent.indexOf(sub);
+      if (intentIdx >= 0) byIntent.splice(intentIdx, 1);
+      if (byIntent.length === 0) this.subscriptionsByIntent.delete(intentName);
+    };
+  }
+  registerInterceptor(intent, interceptor, interceptorId) {
+    const intentName = typeof intent === "string" ? intent : intent.name;
+    this.assertIntentAllowed(intentName);
+    const registration = {
+      registrationId: nextInterceptorRegistrationId(),
+      interceptorId: interceptorId ?? intentName,
+      intentName,
+      interceptor,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.interceptors.push(registration);
+    const interceptorsForIntent = this.interceptorsByIntent.get(intentName) ?? [];
+    interceptorsForIntent.push(registration);
+    this.interceptorsByIntent.set(intentName, interceptorsForIntent);
+    return registration.registrationId;
+  }
+  unregisterInterceptor(registrationId) {
+    const interceptor = this.interceptors.find(
+      (candidate) => candidate.registrationId === registrationId
+    );
+    if (!interceptor) return false;
+    const idx = this.interceptors.indexOf(interceptor);
+    if (idx >= 0) this.interceptors.splice(idx, 1);
+    const byIntent = this.interceptorsByIntent.get(interceptor.intentName);
+    if (byIntent) {
+      const intentIdx = byIntent.indexOf(interceptor);
+      if (intentIdx >= 0) byIntent.splice(intentIdx, 1);
+      if (byIntent.length === 0) this.interceptorsByIntent.delete(interceptor.intentName);
+    }
+    return true;
+  }
+  listInterceptors(intent) {
+    return this.interceptors.filter((interceptor) => !intent || interceptor.intentName === intent).map((interceptor) => ({
+      registrationId: interceptor.registrationId,
+      interceptorId: interceptor.interceptorId,
+      intent: interceptor.intentName,
+      createdAt: interceptor.createdAt,
+      lastInterceptedAt: interceptor.lastInterceptedAt
+    }));
+  }
+  getHistory() {
+    return [...this.history];
+  }
+  clearHistory() {
+    this.history.length = 0;
+  }
+  getTrace() {
+    return [...this.trace];
+  }
+  clearTrace() {
+    this.trace.length = 0;
+  }
+  assertIntentAllowed(intentName) {
+    if (!this.strictRegistry && !this.validateIntentNaming) {
+      return;
+    }
+    if (this.validateIntentNaming) {
+      const validation = validateIntentName(intentName);
+      if (!validation.valid) {
+        throw new InvalidIntentNameError(intentName, validation.reason);
+      }
+    }
+    if (this.strictRegistry && this.intentRegistry && !this.intentRegistry.has(intentName)) {
+      throw new UnregisteredIntentError(intentName);
+    }
+  }
+  assertSourceAllowed(event) {
+    if (!this.requireKnownSource) return;
+    if (!event.metadata.source || event.metadata.source === "unknown") {
+      throw new UnknownEventSourceError(event.intent);
+    }
+    if (this.intentRegistry && !this.intentRegistry.has(event.metadata.source)) {
+      throw new UnknownEventSourceError(event.intent, event.metadata.source);
+    }
+  }
+  assertContractAllowed(event) {
+    if (!this.eventContracts) return;
+    const result = this.eventContracts.validate(event);
+    if (!result.ok && (this.strictEventContracts || result.contract)) {
+      throw new EventContractViolationError(event.intent, result.issues);
+    }
+  }
+  /**
+   * Enforce the OBSERVED producer→event flow (metadata.source → intent) against the
+   * architecture profile's layer rules. This is the runtime counterpart to the
+   * declared-model layer policy: it checks what the system actually did, resolving both
+   * layers directly from the profile. It runs BEFORE the flow is recorded via
+   * registerEventFlow, so in hard mode a rejected flow leaves no edge in the graph.
+   */
+  async assertObservedLayerFlowAllowed(event) {
+    if (this.enforceObservedLayerFlowMode === "off" || !this.architectureProfile) {
+      return;
+    }
+    const source = event.metadata.source;
+    if (!source || source === "unknown") return;
+    const profile = this.architectureProfile;
+    const fromLayer = profile.resolveLayer(source);
+    const toLayer = profile.resolveLayer(event.intent);
+    if (!fromLayer || !toLayer) return;
+    const blocked = profile.rules.find(
+      (rule) => !rule.allowed && rule.from === fromLayer && rule.to === toLayer
+    );
+    if (!blocked) return;
+    const severity = this.enforceObservedLayerFlowMode;
+    const message = blocked.message ?? `Observed layer violation: "${source}" (${fromLayer}) must not produce "${event.intent}" (${toLayer}).`;
+    const details = {
+      source,
+      intent: event.intent,
+      fromLayer,
+      toLayer,
+      severity,
+      message,
+      rule: blocked
+    };
+    this.appendTrace({
+      type: "layer.observedViolation",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      intent: event.intent,
+      correlationId: event.metadata.correlationId,
+      traceId: event.metadata.traceId,
+      spanId: event.metadata.spanId,
+      details
+    });
+    await this.recordAudit("layer.observedViolation", event, details);
+    if (severity === "hard") {
+      throw new ObservedLayerFlowViolationError(source, event.intent, fromLayer, toLayer, message);
+    }
+  }
+  async recordRawPublishDiagnostic(event) {
+    const details = {
+      intent: event.intent,
+      source: event.metadata.source,
+      suggestion: "Publish through a registered intent creator so strict registry, contracts, and agent tooling share one source of truth."
+    };
+    this.appendTrace({
+      type: "event.rawPublish",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      intent: event.intent,
+      correlationId: event.metadata.correlationId,
+      traceId: event.metadata.traceId,
+      spanId: event.metadata.spanId,
+      details
+    });
+    await this.recordAudit("event.rawPublish", event, details);
+  }
+  async applyInterceptors(event) {
+    if (event.metadata.allowInterception === false) {
+      return event;
+    }
+    const matching = [...this.interceptorsByIntent.get(event.intent) ?? []];
+    let current = event;
+    for (const registration of matching) {
+      const patches = [];
+      try {
+        await Promise.resolve(
+          registration.interceptor({
+            event: current,
+            intercept: (patch) => {
+              patches.push(patch);
+            }
+          })
+        );
+        if (patches.length === 0) {
+          continue;
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        let candidate = {
+          ...current,
+          metadata: {
+            ...current.metadata,
+            interceptions: [
+              ...current.metadata.interceptions ?? [],
+              { interceptorId: registration.interceptorId, timestamp }
+            ]
+          }
+        };
+        for (const patch of patches) {
+          candidate = {
+            ...candidate,
+            payload: applyPayloadPatch(candidate.payload, patch),
+            metadata: { ...candidate.metadata }
+          };
+        }
+        this.assertContractAllowed(candidate);
+        current = candidate;
+        registration.lastInterceptedAt = timestamp;
+        this.appendTrace({
+          type: "event.intercepted",
+          timestamp,
+          intent: current.intent,
+          correlationId: current.metadata.correlationId,
+          traceId: current.metadata.traceId,
+          spanId: current.metadata.spanId,
+          details: {
+            registrationId: registration.registrationId,
+            interceptorId: registration.interceptorId,
+            patchesApplied: patches.length
+          }
+        });
+        await this.recordAudit("event.intercepted", current, {
+          registrationId: registration.registrationId,
+          interceptorId: registration.interceptorId,
+          patchesApplied: patches.length
+        });
+      } catch (err) {
+        await this.recordInterceptorError(registration, current, err);
+      }
+    }
+    return current;
+  }
+  async invokeHandler(sub, event) {
+    try {
+      await Promise.resolve(sub.handler(event));
+    } catch (err) {
+      this.appendTrace({
+        type: "handler.error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        intent: event.intent,
+        correlationId: event.metadata.correlationId,
+        traceId: event.metadata.traceId,
+        spanId: event.metadata.spanId,
+        details: { error: err instanceof Error ? err.message : String(err) }
+      });
+      await this.recordAudit("handler.error", event, {
+        handlerIntent: sub.intentName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      if (this.onHandlerError) {
+        await this.safeHook(
+          () => this.onHandlerError(err, event, sub.intentName),
+          "onHandlerError",
+          event
+        );
+      }
+      if (this.rethrowHandlerErrors) {
+        throw err;
+      }
+    }
+  }
+  async safeHook(fn, hookName, event) {
+    try {
+      await Promise.resolve(fn());
+    } catch (err) {
+      this.appendTrace({
+        type: "hook.error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        intent: event.intent,
+        correlationId: event.metadata.correlationId,
+        traceId: event.metadata.traceId,
+        spanId: event.metadata.spanId,
+        details: {
+          hook: hookName,
+          error: err instanceof Error ? err.message : String(err)
+        }
+      });
+      await this.recordAudit("hook.error", event, {
+        hook: hookName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  async recordInterceptorError(interceptor, event, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    this.appendTrace({
+      type: "interceptor.error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      intent: event.intent,
+      correlationId: event.metadata.correlationId,
+      traceId: event.metadata.traceId,
+      spanId: event.metadata.spanId,
+      details: {
+        registrationId: interceptor.registrationId,
+        interceptorId: interceptor.interceptorId,
+        error: message
+      }
+    });
+    await this.recordAudit("interceptor.error", event, {
+      registrationId: interceptor.registrationId,
+      interceptorId: interceptor.interceptorId,
+      error: message
+    });
+  }
+  appendHistory(record) {
+    this.history.push(record);
+    if (this.maxHistorySize !== void 0 && this.history.length > this.maxHistorySize) {
+      this.history.splice(0, this.history.length - this.maxHistorySize);
+    }
+  }
+  appendTrace(record) {
+    this.trace.push(record);
+    if (this.maxHistorySize !== void 0 && this.trace.length > this.maxHistorySize) {
+      this.trace.splice(0, this.trace.length - this.maxHistorySize);
+    }
+    for (const sink of this.traceSinks) {
+      try {
+        sink(record);
+      } catch {
+      }
+    }
+  }
+  async recordAudit(type, event, details) {
+    if (!this.auditTrail) return;
+    try {
+      await this.auditTrail.record({
+        type,
+        source: event.metadata.source,
+        intent: event.intent,
+        correlationId: event.metadata.correlationId,
+        causationId: event.metadata.causationId,
+        subject: event.intent,
+        details
+      });
+    } catch (err) {
+      this.appendTrace({
+        type: "hook.error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        intent: event.intent,
+        correlationId: event.metadata.correlationId,
+        traceId: event.metadata.traceId,
+        spanId: event.metadata.spanId,
+        details: {
+          hook: "auditTrail",
+          error: err instanceof Error ? err.message : String(err)
+        }
+      });
+    }
+  }
+  enrichMetadata(base, extra) {
+    return {
+      ...base,
+      ...extra,
+      occurredAt: extra.occurredAt || base.occurredAt || (/* @__PURE__ */ new Date()).toISOString(),
+      source: extra.source || base.source || "unknown",
+      kernelInstanceId: extra.kernelInstanceId ?? base.kernelInstanceId ?? this.instanceId,
+      eventVersion: extra.eventVersion ?? base.eventVersion,
+      schemaVersion: extra.schemaVersion ?? base.schemaVersion,
+      allowInterception: extra.allowInterception ?? base.allowInterception,
+      interceptions: extra.interceptions ?? base.interceptions,
+      correlationId: extra.correlationId ?? base.correlationId,
+      causationId: extra.causationId ?? base.causationId,
+      traceId: extra.traceId ?? base.traceId,
+      spanId: extra.spanId ?? base.spanId,
+      parentSpanId: extra.parentSpanId ?? base.parentSpanId
+    };
+  }
+};
+function createEventBus(options) {
+  return new EventBusImpl(options);
+}
+
+// src/kernel/event-contracts/EventContractRegistry.ts
+function formatStandardSchemaPath(path) {
+  if (!path || path.length === 0) return void 0;
+  return path.map(
+    (segment) => typeof segment === "object" && segment !== null && "key" in segment ? String(segment.key) : String(segment)
+  ).join(".");
+}
+function actualType(value) {
+  if (Array.isArray(value)) return "array";
+  if (value === null) return "object";
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean" || type === "object") {
+    return type;
+  }
+  return "unknown";
+}
+function formatPath(parent, field) {
+  return parent ? `${parent}.${field}` : field;
+}
+function validateSchemaField(value, fieldSchema, path, contract, issues) {
+  const valueType = actualType(value);
+  if (fieldSchema.type !== "unknown" && valueType !== fieldSchema.type) {
+    issues.push({
+      intent: contract.intent,
+      version: contract.version,
+      field: path,
+      message: `Expected ${fieldSchema.type}, received ${valueType}.`
+    });
+    return;
+  }
+  if (fieldSchema.enum && !fieldSchema.enum.some((allowed) => Object.is(allowed, value))) {
+    issues.push({
+      intent: contract.intent,
+      version: contract.version,
+      field: path,
+      message: "Value is not allowed by event contract enum."
+    });
+  }
+  if (fieldSchema.type === "object" && fieldSchema.fields) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      issues.push({
+        intent: contract.intent,
+        version: contract.version,
+        field: path,
+        message: "Nested object field must be a non-array object."
+      });
+      return;
+    }
+    validateObjectSchema(
+      value,
+      fieldSchema.fields,
+      contract,
+      issues,
+      path
+    );
+  }
+  if (fieldSchema.type === "array" && fieldSchema.items && Array.isArray(value)) {
+    value.forEach((item, index) => {
+      validateSchemaField(
+        item,
+        fieldSchema.items,
+        `${path}[${index}]`,
+        contract,
+        issues
+      );
+    });
+  }
+}
+function validateObjectSchema(payload, schema, contract, issues, parentPath) {
+  for (const [field, fieldSchema] of Object.entries(schema)) {
+    const path = formatPath(parentPath, field);
+    const value = payload[field];
+    if (value === void 0) {
+      if (fieldSchema.required) {
+        issues.push({
+          intent: contract.intent,
+          version: contract.version,
+          field: path,
+          message: "Required field is missing."
+        });
+      }
+      continue;
+    }
+    validateSchemaField(value, fieldSchema, path, contract, issues);
+  }
+}
+var EventContractRegistryImpl = class {
+  contracts = /* @__PURE__ */ new Map();
+  register(contract) {
+    const key = this.key(contract.intent, contract.version);
+    if (this.contracts.has(key)) {
+      throw new Error(`Event contract "${key}" is already registered.`);
+    }
+    this.contracts.set(key, { allowAdditionalFields: true, ...contract });
+  }
+  get(intent, version2) {
+    if (version2) return this.contracts.get(this.key(intent, version2));
+    return this.list(intent).at(-1);
+  }
+  list(intent) {
+    return Array.from(this.contracts.values()).filter(
+      (contract) => !intent || contract.intent === intent
+    );
+  }
+  validate(event) {
+    const version2 = event.metadata.eventVersion;
+    const contract = this.get(event.intent, version2);
+    const issues = [];
+    if (!contract) {
+      return {
+        ok: false,
+        issues: [
+          {
+            intent: event.intent,
+            version: version2,
+            message: version2 ? `No event contract registered for version "${version2}".` : "No event contract registered for intent."
+          }
+        ]
+      };
+    }
+    if (contract.deprecated) {
+      issues.push({
+        intent: event.intent,
+        version: contract.version,
+        message: typeof contract.deprecated === "string" ? contract.deprecated : "Event contract is deprecated."
+      });
+    }
+    const payload = event.payload != null && typeof event.payload === "object" ? event.payload : void 0;
+    if (contract.schema) {
+      if (!payload) {
+        issues.push({
+          intent: event.intent,
+          version: contract.version,
+          message: "Payload must be an object for schema validation."
+        });
+      } else {
+        validateObjectSchema(payload, contract.schema, contract, issues);
+        if (contract.allowAdditionalFields === false) {
+          for (const field of Object.keys(payload)) {
+            if (!contract.schema[field]) {
+              issues.push({
+                intent: event.intent,
+                version: contract.version,
+                field,
+                message: "Additional field is not allowed by event contract."
+              });
+            }
+          }
+        }
+      }
+    }
+    if (contract.standardSchema) {
+      const result = contract.standardSchema["~standard"].validate(event.payload);
+      if (result instanceof Promise) {
+        issues.push({
+          intent: event.intent,
+          version: contract.version,
+          message: "Standard Schema validator returned a Promise; event contract validation is synchronous."
+        });
+      } else if (result.issues) {
+        for (const issue of result.issues) {
+          issues.push({
+            intent: event.intent,
+            version: contract.version,
+            field: formatStandardSchemaPath(issue.path),
+            message: issue.message
+          });
+        }
+      }
+    }
+    return { ok: issues.length === 0, contract, issues };
+  }
+  clear() {
+    this.contracts.clear();
+  }
+  key(intent, version2) {
+    return `${intent}@${version2}`;
+  }
+};
+function createEventContractRegistry() {
+  return new EventContractRegistryImpl();
+}
+
+// src/kernel/graph/DependencyGraph.ts
+var DependencyGraphImpl = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  registerDependency(from, to, kind = "declared") {
+    this.ensureNode(from);
+    this.ensureNode(to);
+    this.addEdge({ from, to, kind });
+  }
+  registerEventFlow(producer, consumer) {
+    this.ensureNode(producer);
+    this.ensureNode(consumer);
+    this.addEdge({ from: producer, to: consumer, kind: "observed" });
+  }
+  getNodes() {
+    return Array.from(this.nodes.values());
+  }
+  getEdges() {
+    return [...this.edges];
+  }
+  toJSON() {
+    return {
+      nodes: this.getNodes(),
+      edges: this.getEdges()
+    };
+  }
+  toMermaid() {
+    let out = "flowchart TD\n";
+    for (const edge of this.edges) {
+      const label = edge.kind ? `|${edge.kind}|` : "";
+      out += `  ${this.safeId(edge.from)} -->${label} ${this.safeId(edge.to)}
+`;
+    }
+    const connected = new Set(
+      this.edges.flatMap((e) => [e.from, e.to])
+    );
+    for (const node of this.nodes.keys()) {
+      if (!connected.has(node)) {
+        out += `  ${this.safeId(node)}
+`;
+      }
+    }
+    return out.trim();
+  }
+  toLayerMermaid(profile) {
+    const nodesByLayer = /* @__PURE__ */ new Map();
+    for (const node of this.nodes.keys()) {
+      const layer = profile.resolveLayer(node) ?? "Unclassified";
+      const current = nodesByLayer.get(layer) ?? [];
+      current.push(node);
+      nodesByLayer.set(layer, current);
+    }
+    let out = "flowchart TD\n";
+    for (const layer of profile.layers) {
+      const nodes = nodesByLayer.get(layer.name) ?? [];
+      if (nodes.length === 0) continue;
+      out += `  subgraph ${this.safeId(layer.name)}[${layer.name}]
+`;
+      for (const node of nodes) {
+        out += `    ${this.safeId(node)}[${node}]
+`;
+      }
+      out += "  end\n";
+    }
+    const unclassified = nodesByLayer.get("Unclassified") ?? [];
+    if (unclassified.length > 0) {
+      out += "  subgraph Unclassified[Unclassified]\n";
+      for (const node of unclassified) {
+        out += `    ${this.safeId(node)}[${node}]
+`;
+      }
+      out += "  end\n";
+    }
+    for (const edge of this.edges) {
+      const label = edge.kind ? `|${edge.kind}|` : "";
+      out += `  ${this.safeId(edge.from)} -->${label} ${this.safeId(edge.to)}
+`;
+    }
+    return out.trim();
+  }
+  detectViolations(rules = []) {
+    const violations = [];
+    const cycles = this.findSimpleCycles();
+    if (cycles.length > 0) {
+      violations.push(`Cycle detected: ${cycles.map((c) => c.join("->")).join(", ")}`);
+    }
+    for (const rule of rules) {
+      try {
+        const res = rule(this.edges);
+        if (res && res.length) violations.push(...res);
+      } catch (e) {
+        violations.push(`Rule error: ${e.message}`);
+      }
+    }
+    return violations;
+  }
+  ensureNode(id) {
+    if (!this.nodes.has(id)) {
+      this.nodes.set(id, { id });
+    }
+  }
+  addEdge(edge) {
+    const exists = this.edges.some(
+      (e) => e.from === edge.from && e.to === edge.to && e.kind === edge.kind
+    );
+    if (!exists) {
+      this.edges.push(edge);
+    }
+  }
+  // Very naive cycle detection for small graphs
+  findSimpleCycles() {
+    const graph = /* @__PURE__ */ new Map();
+    for (const e of this.edges) {
+      if (!graph.has(e.from)) graph.set(e.from, []);
+      graph.get(e.from).push(e.to);
+    }
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const stack = [];
+    const dfs = (node) => {
+      visited.add(node);
+      stack.push(node);
+      for (const nei of graph.get(node) || []) {
+        if (!visited.has(nei)) {
+          dfs(nei);
+        } else if (stack.includes(nei)) {
+          const cycleStart = stack.indexOf(nei);
+          const cycle = stack.slice(cycleStart).concat(nei);
+          cycles.push(cycle);
+        }
+      }
+      stack.pop();
+    };
+    for (const node of graph.keys()) {
+      if (!visited.has(node)) dfs(node);
+    }
+    const unique = new Set(cycles.map((c) => c.join("->")));
+    return Array.from(unique).map((s) => s.split("->"));
+  }
+  safeId(id) {
+    return id.replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+};
+function createDependencyGraph() {
+  return new DependencyGraphImpl();
+}
+
+// src/kernel/graph/sync.ts
+function syncRegistryToGraph(registry, graph, options = {}) {
+  const requireRegistered = options.requireRegisteredTargets ?? false;
+  for (const rel of registry.getAllRelationships()) {
+    if (requireRegistered && !registry.has(rel.to)) {
+      continue;
+    }
+    if (rel.kind === "dependsOn") {
+      graph.registerDependency(rel.from, rel.to, "declared");
+    } else {
+      graph.registerDependency(rel.from, rel.to, "produces");
+    }
+  }
+}
+
+// src/kernel/intent/IntentRegistry.ts
+var IntentRegistry = class {
+  intents = /* @__PURE__ */ new Map();
+  dependencies = /* @__PURE__ */ new Map();
+  productions = /* @__PURE__ */ new Map();
+  /**
+   * Define/register a new intent.
+   *
+   * @param name - Semantic intent name following the convention (Domain.*, Application.*, etc.)
+   * @param options - Optional relationship declarations
+   * @throws Error if an intent with the same name is already registered
+   */
+  define(name, options) {
+    if (this.intents.has(name)) {
+      throw new Error(
+        `Intent "${name}" is already registered. Intent names must be unique within a registry.`
+      );
+    }
+    const fn = (payload) => ({
+      intent: name,
+      payload,
+      metadata: {
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "unknown"
+      }
+    });
+    Object.defineProperty(fn, "name", {
+      value: name,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+    const creator = fn;
+    this.intents.set(name, creator);
+    if (options?.dependsOn) {
+      for (const dep of options.dependsOn) {
+        this.declareDependency(name, dep);
+      }
+    }
+    if (options?.produces) {
+      for (const prod of options.produces) {
+        this.declareProduction(name, prod);
+      }
+    }
+    return creator;
+  }
+  /**
+   * Declare that one intent depends on / relates to another.
+   * This information is used by the DependencyGraph (future iterations) and for policy checks.
+   *
+   * @param from - The source intent (e.g. an Application operation)
+   * @param to - The target intent it depends on (e.g. a Domain event or concept)
+   */
+  declareDependency(from, to) {
+    if (!this.dependencies.has(from)) {
+      this.dependencies.set(from, /* @__PURE__ */ new Set());
+    }
+    this.dependencies.get(from).add(to);
+  }
+  /**
+   * Declare that one intent produces / emits another (e.g. use case → domain event).
+   */
+  declareProduction(from, to) {
+    if (!this.productions.has(from)) {
+      this.productions.set(from, /* @__PURE__ */ new Set());
+    }
+    this.productions.get(from).add(to);
+  }
+  /**
+   * Retrieve a previously defined intent creator by name.
+   */
+  get(name) {
+    return this.intents.get(name);
+  }
+  /**
+   * List all registered intent creators.
+   */
+  list() {
+    return Array.from(this.intents.values());
+  }
+  /**
+   * Get all declared dependencies for a given intent.
+   */
+  getDependencies(intentName) {
+    const deps = this.dependencies.get(intentName);
+    return deps ? Array.from(deps) : [];
+  }
+  /**
+   * Get all intents produced / emitted by a given intent.
+   */
+  getProductions(intentName) {
+    const prods = this.productions.get(intentName);
+    return prods ? Array.from(prods) : [];
+  }
+  /**
+   * Get all declared relationships (useful for graph generation).
+   */
+  getAllRelationships() {
+    const result = [];
+    for (const [from, tos] of this.dependencies.entries()) {
+      for (const to of tos) {
+        result.push({ from, to, kind: "dependsOn" });
+      }
+    }
+    for (const [from, tos] of this.productions.entries()) {
+      for (const to of tos) {
+        result.push({ from, to, kind: "produces" });
+      }
+    }
+    return result;
+  }
+  /**
+   * Check if an intent name has been registered.
+   */
+  has(name) {
+    return this.intents.has(name);
+  }
+  /**
+   * Clear the registry. Primarily useful for tests.
+   */
+  clear() {
+    this.intents.clear();
+    this.dependencies.clear();
+    this.productions.clear();
+  }
+};
+function createIntentRegistry() {
+  return new IntentRegistry();
+}
+
+// src/kernel/layers/ArchitectureProfile.ts
+function normalizePrefix(prefix) {
+  return prefix.endsWith(".") ? prefix : `${prefix}.`;
+}
+function byLongestPrefix(a, b) {
+  const maxA = Math.max(...a.prefixes.map((p) => p.length));
+  const maxB = Math.max(...b.prefixes.map((p) => p.length));
+  return maxB - maxA;
+}
+function flowKey(from, to) {
+  return `${from}->${to}`;
+}
+function createStrictDenyRules(layers, allowedFlows) {
+  const allowed = new Set(allowedFlows.map((flow) => flowKey(flow.from, flow.to)));
+  const rules = [];
+  for (const from of layers) {
+    for (const to of layers) {
+      if (from.name === to.name) continue;
+      if (allowed.has(flowKey(from.name, to.name))) continue;
+      rules.push({ from: from.name, to: to.name, allowed: false });
+    }
+  }
+  return rules;
+}
+function createArchitectureProfile(options) {
+  const layers = options.layers.map((layer) => ({
+    ...layer,
+    prefixes: layer.prefixes.map(normalizePrefix)
+  }));
+  const sortedLayers = [...layers].sort(byLongestPrefix);
+  const rules = [...options.rules ?? []];
+  return {
+    name: options.name,
+    layers,
+    rules,
+    resolveLayer(name) {
+      return sortedLayers.find(
+        (layer) => layer.prefixes.some((prefix) => name.startsWith(prefix))
+      )?.name;
+    }
+  };
+}
+var elevenLayerProfileLayers = [
+  {
+    name: "DomainModel",
+    prefixes: ["Domain"],
+    description: "Rich domain model, business rules, and domain events.",
+    order: 1
+  },
+  {
+    name: "ApplicationOrchestration",
+    prefixes: ["Application"],
+    description: "Use cases and command orchestration.",
+    order: 2
+  },
+  {
+    name: "PersistenceAdapters",
+    prefixes: ["Adapter.Persistence", "Adapter.Repository"],
+    description: "Database, repository, and storage adapters.",
+    order: 3
+  },
+  {
+    name: "IntegrationAdapters",
+    prefixes: ["Adapter.Integration", "Adapter.External"],
+    description: "External systems, APIs, and integration adapters.",
+    order: 4
+  },
+  {
+    name: "WorkflowSagaEngine",
+    prefixes: ["Workflow"],
+    description: "Sagas, workflows, and long-running processes.",
+    order: 5
+  },
+  {
+    name: "BackgroundJobsScheduling",
+    prefixes: ["Job"],
+    description: "Background jobs, scheduled work, and async processors.",
+    order: 6
+  },
+  {
+    name: "PresentationAdapters",
+    prefixes: ["Presentation", "Adapter.Presentation", "Adapter.Api"],
+    description: "API, UI, controller, and presentation adapters.",
+    order: 7
+  },
+  {
+    name: "ReportingReadModels",
+    prefixes: ["Reporting"],
+    description: "Read models, projections, and reporting surfaces.",
+    order: 8
+  },
+  {
+    name: "ExtensibilityMetadata",
+    prefixes: ["Metadata"],
+    description: "Metadata, extensions, and schema contracts.",
+    order: 9
+  },
+  {
+    name: "SecurityAuditObservability",
+    prefixes: ["Security", "Audit", "Observability"],
+    description: "Security, audit, and observability concerns.",
+    order: 10
+  },
+  {
+    name: "Kernel",
+    prefixes: ["Kernel"],
+    description: "Ark-owned governance and kernel signals.",
+    order: 11
+  }
+];
+var elevenLayerAllowedFlows = [
+  { from: "PresentationAdapters", to: "ApplicationOrchestration" },
+  { from: "ApplicationOrchestration", to: "DomainModel" },
+  { from: "WorkflowSagaEngine", to: "ApplicationOrchestration" },
+  { from: "WorkflowSagaEngine", to: "DomainModel" },
+  { from: "BackgroundJobsScheduling", to: "ApplicationOrchestration" }
+];
+var elevenLayerProfile = createArchitectureProfile({
+  name: "Ark 11-layer Hexagonal Event-Driven Profile",
+  layers: elevenLayerProfileLayers,
+  rules: createStrictDenyRules(
+    elevenLayerProfileLayers,
+    elevenLayerAllowedFlows
+  )
+});
+
+// src/kernel/manifest/constants.ts
+var MANIFEST_SCHEMA_VERSION = "1.0";
+
+// src/version.ts
+var version = "1.0.0";
+
+// src/kernel/manifest/createArkManifest.ts
+function policyId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var ArkManifestImpl = class {
+  constructor(data) {
+    this.data = data;
+  }
+  data;
+  toJSON() {
+    return { ...this.data };
+  }
+};
+function createArkManifest(options = {}) {
+  const registry = options.registry;
+  const policyEngine = options.policyEngine;
+  const metadata = options.metadata;
+  const graph = options.graph;
+  const profile = options.profile;
+  const projections = options.projections;
+  const eventContracts = options.eventContracts;
+  const observability = options.observability;
+  const intents = registry ? registry.list().map((creator) => ({
+    name: creator.name,
+    dependencies: registry.getDependencies(creator.name),
+    productions: registry.getProductions(creator.name)
+  })) : [];
+  const relationships = registry ? registry.getAllRelationships() : [];
+  const policies = policyEngine ? policyEngine.getPolicies().map((p) => ({
+    id: policyId(p.name),
+    name: p.name,
+    severity: p.severity,
+    tags: p.tags ? [...p.tags] : void 0,
+    owner: p.owner,
+    version: p.version,
+    rationale: p.rationale,
+    enforcementMode: p.enforcementMode,
+    deprecated: p.deprecated,
+    replacedBy: p.replacedBy,
+    description: p.tags?.includes("layer") ? "Enforces clean-architecture layer dependency rules on declared relationships." : void 0
+  })) : [];
+  const entities = metadata ? metadata.toJSON() : [];
+  const graphData = graph ? graph.toJSON() : { nodes: [], edges: [] };
+  const entityIntents = entities.filter((e) => (e.emits?.length ?? 0) > 0 || (e.consumes?.length ?? 0) > 0).map((e) => ({
+    entity: e.name,
+    emits: e.emits,
+    consumes: e.consumes
+  }));
+  const projectionData = projections ? projections.list().map((projection) => ({
+    name: projection.name,
+    sourceIntents: projection.sourceIntents,
+    checkpoint: projections.getCheckpoint(projection.name)
+  })) : [];
+  const data = {
+    schemaVersion: MANIFEST_SCHEMA_VERSION,
+    version,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    intents,
+    relationships,
+    policies,
+    entities,
+    graph: graphData,
+    architecture: profile ? {
+      profile: profile.name,
+      layers: profile.layers,
+      rules: profile.rules
+    } : void 0,
+    projections: projectionData,
+    eventContracts: eventContracts?.list() ?? [],
+    observability: observability?.report(),
+    links: { entityIntents }
+  };
+  return new ArkManifestImpl(data);
+}
+
+// src/kernel/metadata/MetadataRegistry.ts
+var MetadataRegistryImpl = class {
+  entities = /* @__PURE__ */ new Map();
+  entity(name, meta, options = {}) {
+    if (this.entities.has(name) && !options.allowOverwrite) {
+      throw new Error(`Entity metadata "${name}" is already registered.`);
+    }
+    const full = { name, fields: {}, ...meta };
+    this.entities.set(name, full);
+    return full;
+  }
+  getEntity(name) {
+    return this.entities.get(name);
+  }
+  listEntities() {
+    return Array.from(this.entities.values());
+  }
+  findEntitiesByIntent(intentName) {
+    return this.listEntities().filter(
+      (entity) => entity.emits?.includes(intentName) || entity.consumes?.includes(intentName)
+    );
+  }
+  validate() {
+    const issues = [];
+    for (const entity of this.entities.values()) {
+      if (!entity.name.trim()) {
+        issues.push({ entity: entity.name, message: "Entity name is required." });
+      }
+      for (const [fieldName, field] of Object.entries(entity.fields)) {
+        if (!fieldName.trim()) {
+          issues.push({ entity: entity.name, field: fieldName, message: "Field name is required." });
+        }
+        if (!field.type || typeof field.type !== "string") {
+          issues.push({
+            entity: entity.name,
+            field: fieldName,
+            message: "Field type must be a non-empty string."
+          });
+        }
+        if (field.relation && !this.entities.has(field.relation.entity)) {
+          issues.push({
+            entity: entity.name,
+            field: fieldName,
+            message: `Related entity "${field.relation.entity}" is not registered.`
+          });
+        }
+      }
+    }
+    return { ok: issues.length === 0, issues };
+  }
+  toJSON() {
+    return this.listEntities();
+  }
+};
+function createMetadataRegistry() {
+  return new MetadataRegistryImpl();
+}
+
+// src/kernel/observability/ObservabilityReporter.ts
+function flowKey2(flow) {
+  return `${flow.from}->${flow.to}`;
+}
+function uniqueFlows(flows) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const flow of flows) {
+    const key = flowKey2(flow);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(flow);
+  }
+  return result;
+}
+function difference(left, right) {
+  const rightKeys = new Set(right.map(flowKey2));
+  return left.filter((flow) => !rightKeys.has(flowKey2(flow)));
+}
+function createObservabilityReporter(options) {
+  const registry = options.registry;
+  const eventBus = options.eventBus;
+  const graph = options.graph;
+  return {
+    report() {
+      const declaredFromRegistry = registry ? registry.getAllRelationships().filter((relationship) => relationship.kind === "produces").map((relationship) => ({
+        from: relationship.from,
+        to: relationship.to
+      })) : [];
+      const declaredFromGraph = declaredFromRegistry.length > 0 || !graph ? [] : graph.getEdges().filter((edge) => edge.kind === "produces").map((edge) => ({ from: edge.from, to: edge.to }));
+      const observedFromHistory = eventBus?.getHistory().map((record) => ({
+        from: record.event.metadata.source,
+        to: record.event.intent
+      })) ?? [];
+      const observedFromGraph = observedFromHistory.length > 0 || !graph ? [] : graph.getEdges().filter((edge) => edge.kind === "observed").map((edge) => ({ from: edge.from, to: edge.to }));
+      const declaredProductions = uniqueFlows([
+        ...declaredFromRegistry,
+        ...declaredFromGraph
+      ]);
+      const observedProductions = uniqueFlows([
+        ...observedFromHistory,
+        ...observedFromGraph
+      ]);
+      const unknownSources = observedProductions.filter(
+        (flow) => !flow.from || flow.from === "unknown"
+      );
+      const unregisteredObservedSources = registry ? Array.from(
+        new Set(
+          observedProductions.map((flow) => flow.from).filter(
+            (source) => source && source !== "unknown" && !registry.has(source)
+          )
+        )
+      ) : [];
+      const unregisteredObservedIntents = registry ? Array.from(
+        new Set(
+          observedProductions.map((flow) => flow.to).filter((intent) => !registry.has(intent))
+        )
+      ) : [];
+      const observedIntentNames = new Set(
+        observedProductions.flatMap((flow) => [flow.from, flow.to])
+      );
+      const registeredButNeverObserved = registry ? registry.list().map((intent) => intent.name).filter((intent) => !observedIntentNames.has(intent)) : [];
+      return {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        declaredProductions,
+        observedProductions,
+        declaredButUnobserved: difference(declaredProductions, observedProductions),
+        observedButUndeclared: difference(
+          observedProductions.filter((flow) => flow.from !== "unknown"),
+          declaredProductions
+        ),
+        unknownSources,
+        unregisteredObservedSources,
+        unregisteredObservedIntents,
+        registeredButNeverObserved
+      };
+    }
+  };
+}
+
+// src/kernel/outbox/InMemoryOutboxStore.ts
+var outboxSequence = 0;
+function nextOutboxId() {
+  outboxSequence += 1;
+  return `outbox-${Date.now()}-${outboxSequence}`;
+}
+function cloneRecord(record) {
+  return {
+    ...record,
+    event: {
+      ...record.event,
+      metadata: { ...record.event.metadata }
+    }
+  };
+}
+var InMemoryOutboxStore = class {
+  records = /* @__PURE__ */ new Map();
+  async enqueue(event) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      id: nextOutboxId(),
+      event,
+      status: "pending",
+      attempts: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.records.set(record.id, record);
+    return cloneRecord(record);
+  }
+  async markDispatched(id) {
+    const record = this.records.get(id);
+    if (!record) return;
+    record.status = "dispatched";
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async markFailed(id, error) {
+    const record = this.records.get(id);
+    if (!record) return;
+    record.status = "failed";
+    record.attempts += 1;
+    record.error = error instanceof Error ? error.message : String(error);
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async list(status) {
+    return Array.from(this.records.values()).filter((record) => !status || record.status === status).map(cloneRecord);
+  }
+  async clear() {
+    this.records.clear();
+  }
+};
+
+// src/kernel/projections/ProjectionRegistry.ts
+var InMemoryReadModelStore = class {
+  states = /* @__PURE__ */ new Map();
+  load(name) {
+    return this.states.get(name);
+  }
+  save(name, state) {
+    this.states.set(name, state);
+  }
+  clear(name) {
+    if (name) {
+      this.states.delete(name);
+    } else {
+      this.states.clear();
+    }
+  }
+};
+function initialState(definition) {
+  return typeof definition.initialState === "function" ? definition.initialState() : definition.initialState;
+}
+var ProjectionRegistryImpl = class {
+  definitions = /* @__PURE__ */ new Map();
+  checkpoints = /* @__PURE__ */ new Map();
+  store;
+  auditTrail;
+  constructor(options = {}) {
+    this.store = options.store ?? new InMemoryReadModelStore();
+    this.auditTrail = options.auditTrail;
+  }
+  register(definition) {
+    if (this.definitions.has(definition.name)) {
+      throw new Error(`Projection "${definition.name}" is already registered.`);
+    }
+    this.definitions.set(definition.name, definition);
+    this.checkpoints.set(definition.name, {
+      projection: definition.name,
+      appliedCount: 0
+    });
+  }
+  list() {
+    return Array.from(this.definitions.values());
+  }
+  async apply(event) {
+    const applied = [];
+    for (const definition of this.definitions.values()) {
+      if (!definition.sourceIntents.includes(event.intent)) continue;
+      const current = await this.store.load(definition.name) ?? initialState(definition);
+      const next = await definition.project(event, current);
+      await this.store.save(definition.name, next);
+      const previous = this.checkpoints.get(definition.name);
+      this.checkpoints.set(definition.name, {
+        projection: definition.name,
+        appliedCount: (previous?.appliedCount ?? 0) + 1,
+        lastIntent: event.intent,
+        lastCorrelationId: event.metadata.correlationId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await this.auditTrail?.record({
+        type: "projection.applied",
+        source: "Kernel.ProjectionRegistry",
+        intent: event.intent,
+        correlationId: event.metadata.correlationId,
+        causationId: event.metadata.causationId,
+        subject: definition.name,
+        details: { projection: definition.name }
+      });
+      applied.push(definition.name);
+    }
+    return applied;
+  }
+  async getState(name) {
+    return this.store.load(name);
+  }
+  getCheckpoint(name) {
+    return this.checkpoints.get(name);
+  }
+  getCheckpoints() {
+    return Array.from(this.checkpoints.values());
+  }
+  async clear() {
+    await this.store.clear();
+    for (const definition of this.definitions.values()) {
+      this.checkpoints.set(definition.name, {
+        projection: definition.name,
+        appliedCount: 0
+      });
+    }
+  }
+};
+function createProjectionRegistry(options) {
+  return new ProjectionRegistryImpl(options);
+}
+
+// src/kernel/workflow/Saga.ts
+var workflowSequence = 0;
+function createWorkflowId(prefix) {
+  workflowSequence += 1;
+  return `${prefix}-${Date.now()}-${workflowSequence}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function withTimeout(operation, timeoutMs, stepName) {
+  if (timeoutMs === void 0) return operation;
+  let timeout;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeout = setTimeout(() => {
+      reject(new Error(`Workflow step "${stepName}" timed out after ${timeoutMs}ms.`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([operation, timeoutPromise]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+var InMemoryWorkflowStore = class {
+  snapshots = /* @__PURE__ */ new Map();
+  save(snapshot) {
+    this.snapshots.set(snapshot.id, { ...snapshot, context: { ...snapshot.context } });
+  }
+  get(id) {
+    const snapshot = this.snapshots.get(id);
+    return snapshot ? { ...snapshot, context: { ...snapshot.context } } : void 0;
+  }
+  list(workflowName) {
+    return Array.from(this.snapshots.values()).filter((snapshot) => !workflowName || snapshot.workflowName === workflowName).map((snapshot) => ({ ...snapshot, context: { ...snapshot.context } }));
+  }
+  clear() {
+    this.snapshots.clear();
+  }
+};
+var WorkflowEngineImpl = class {
+  constructor(bus, options = {}) {
+    this.bus = bus;
+    this.options = options;
+    this.store = options.store ?? new InMemoryWorkflowStore();
+  }
+  bus;
+  options;
+  definitions = /* @__PURE__ */ new Map();
+  store;
+  register(definition) {
+    if (this.definitions.has(definition.name)) {
+      throw new Error(`Workflow "${definition.name}" is already registered.`);
+    }
+    this.definitions.set(definition.name, definition);
+    if (definition.startOn) {
+      const trigger = definition.startOn;
+      this.bus.subscribe(trigger.intent, async (event) => {
+        await this.start(definition.name, trigger.mapEventToPayload(event));
+      });
+    }
+  }
+  async start(workflowName, initialPayload, options = {}) {
+    const definition = this.definitions.get(workflowName);
+    if (!definition) {
+      throw new Error(`Workflow "${workflowName}" is not registered.`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const snapshot = {
+      id: options.id ?? createWorkflowId(workflowName),
+      workflowName,
+      status: "running",
+      context: { ...initialPayload },
+      completedSteps: [],
+      attempts: {},
+      startedAt: now,
+      updatedAt: now
+    };
+    await this.store.save(snapshot);
+    await this.audit("workflow.started", snapshot, { workflowName });
+    try {
+      for (const step of definition.steps) {
+        await this.runStep(snapshot, step);
+      }
+      snapshot.status = "completed";
+      snapshot.currentStep = void 0;
+      snapshot.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      snapshot.updatedAt = snapshot.completedAt;
+      await this.store.save(snapshot);
+      await this.audit("workflow.completed", snapshot, { workflowName });
+      return { ...snapshot, context: { ...snapshot.context } };
+    } catch (err) {
+      await this.compensate(snapshot, definition.steps, err);
+      snapshot.status = "failed";
+      snapshot.error = errorMessage(err);
+      snapshot.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.store.save(snapshot);
+      await this.audit("workflow.failed", snapshot, {
+        workflowName,
+        error: snapshot.error,
+        failedStep: snapshot.failedStep
+      });
+      throw err;
+    }
+  }
+  async get(id) {
+    return this.store.get(id);
+  }
+  async list(workflowName) {
+    return this.store.list(workflowName);
+  }
+  async runStep(snapshot, step) {
+    const retry = step.retry ?? this.options.defaultRetry ?? { attempts: 1 };
+    const maxAttempts = Math.max(1, retry.attempts);
+    snapshot.currentStep = step.name;
+    snapshot.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.store.save(snapshot);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      snapshot.attempts[step.name] = attempt;
+      await this.store.save(snapshot);
+      try {
+        const result = await withTimeout(
+          Promise.resolve(step.execute(snapshot.context, this.bus)),
+          step.timeoutMs,
+          step.name
+        );
+        if (result) Object.assign(snapshot.context, result);
+        snapshot.completedSteps.push(step.name);
+        snapshot.currentStep = void 0;
+        snapshot.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await this.store.save(snapshot);
+        await this.audit("workflow.step.completed", snapshot, {
+          step: step.name,
+          attempt
+        });
+        return;
+      } catch (err) {
+        if (attempt < maxAttempts) {
+          if (retry.delayMs) await sleep(retry.delayMs);
+          continue;
+        }
+        snapshot.failedStep = step.name;
+        snapshot.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await this.store.save(snapshot);
+        await this.audit("workflow.step.failed", snapshot, {
+          step: step.name,
+          attempt,
+          error: errorMessage(err)
+        });
+        throw err;
+      }
+    }
+    throw new Error(`Workflow step "${step.name}" did not complete.`);
+  }
+  async compensate(snapshot, steps, error) {
+    snapshot.status = "compensating";
+    snapshot.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.store.save(snapshot);
+    const completed = steps.filter(
+      (step) => snapshot.completedSteps.includes(step.name)
+    );
+    for (let index = completed.length - 1; index >= 0; index -= 1) {
+      const step = completed[index];
+      if (!step.compensate) continue;
+      try {
+        await Promise.resolve(step.compensate(snapshot.context, this.bus, error));
+        await this.audit("workflow.compensation.completed", snapshot, {
+          step: step.name
+        });
+      } catch (compensationError) {
+        await this.audit("workflow.step.failed", snapshot, {
+          step: step.name,
+          compensation: true,
+          error: errorMessage(compensationError)
+        });
+      }
+    }
+  }
+  async audit(type, snapshot, details) {
+    await this.options.auditTrail?.record({
+      type,
+      source: "Kernel.WorkflowEngine",
+      subject: snapshot.id,
+      details
+    });
+  }
+};
+function createWorkflowEngine(bus, options) {
+  return new WorkflowEngineImpl(bus, options);
+}
+
+// src/kernel/runtime/createArkKernel.ts
+var kernelSequence = 0;
+function nextKernelInstanceId() {
+  kernelSequence += 1;
+  return `ark-kernel-${Date.now()}-${kernelSequence}`;
+}
+function createArkKernel(options = {}) {
+  const strict = options.strict ?? true;
+  const instanceId = options.instanceId ?? nextKernelInstanceId();
+  const profile = options.profile ?? elevenLayerProfile;
+  const registry = createIntentRegistry();
+  const graph = createDependencyGraph();
+  const metadata = options.metadata ?? createMetadataRegistry();
+  const auditTrail = options.auditTrail ?? createAuditTrail({ maxRecords: options.maxHistorySize });
+  const eventContracts = options.eventContracts ?? createEventContractRegistry();
+  const outbox = options.outbox ?? new InMemoryOutboxStore();
+  const projections = options.projections ?? createProjectionRegistry({ auditTrail });
+  const policyEngine = new PolicyEngine([
+    defineArchitectureProfilePolicy(profile),
+    ...options.policies ?? []
+  ]);
+  const syncGraph = () => {
+    syncRegistryToGraph(registry, graph, { requireRegisteredTargets: true });
+  };
+  const eventBus = createEventBus({
+    intentRegistry: registry,
+    dependencyGraph: graph,
+    policyEngine,
+    strictRegistry: true,
+    validateIntentNaming: true,
+    auditTrail,
+    eventContracts,
+    strictEventContracts: options.strictEventContracts ?? strict,
+    requireKnownSource: options.requireKnownSource ?? true,
+    architectureProfile: profile,
+    enforceObservedLayerFlow: options.enforceObservedLayerFlow ?? (strict ? "hard" : "off"),
+    outbox,
+    instanceId,
+    maxHistorySize: options.maxHistorySize,
+    onPublish: options.autoApplyProjections === false ? void 0 : async (event) => {
+      await projections.apply(event);
+    }
+  });
+  const workflowEngine = createWorkflowEngine(eventBus, { auditTrail });
+  const observability = createObservabilityReporter({
+    registry,
+    eventBus,
+    graph
+  });
+  return {
+    instanceId,
+    profile,
+    registry,
+    graph,
+    metadata,
+    auditTrail,
+    eventContracts,
+    outbox,
+    projections,
+    policyEngine,
+    eventBus,
+    workflowEngine,
+    observability,
+    publisher(source) {
+      return eventBus.createPublisher(source);
+    },
+    syncGraph,
+    manifest() {
+      syncGraph();
+      return createArkManifest({
+        registry,
+        policyEngine,
+        metadata,
+        graph,
+        profile,
+        projections,
+        eventContracts,
+        observability
+      });
+    }
+  };
+}
+
+// src/nestjs/index.ts
+var ARK_KERNEL = /* @__PURE__ */ Symbol("ARK_KERNEL");
+var InjectArk = () => Inject(ARK_KERNEL);
+var ArkModule = class {
+  /**
+   * Registers a global Ark kernel. Pass an existing kernel to share one across
+   * processes/tests, or options to create a fresh strict kernel.
+   */
+  static forRoot(kernelOrOptions) {
+    const kernel = kernelOrOptions && "registry" in kernelOrOptions ? kernelOrOptions : createArkKernel(kernelOrOptions);
+    return {
+      module: ArkModule,
+      global: true,
+      providers: [{ provide: ARK_KERNEL, useValue: kernel }],
+      exports: [ARK_KERNEL]
+    };
+  }
+  static forRootAsync(options) {
+    return {
+      module: ArkModule,
+      global: true,
+      providers: [
+        {
+          provide: ARK_KERNEL,
+          useFactory: options.useFactory,
+          inject: options.inject ?? []
+        }
+      ],
+      exports: [ARK_KERNEL]
+    };
+  }
+};
+ArkModule = __decorateClass([
+  Module({})
+], ArkModule);
+
+export { ARK_KERNEL, ArkModule, InjectArk };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map