@fabricorg/platform 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,1357 +1,15 @@
-import assert from 'assert';
-
-// actions/index.ts
-var ACTOR_TYPES = [
-  "natural_person",
-  "agent",
-  "system",
-  "service_account",
-  "external_system",
-  "integration"
-];
-function isActorType(value) {
-  return ACTOR_TYPES.includes(value);
-}
-function assertActorType(value) {
-  if (!isActorType(value)) {
-    throw new Error(`Invalid actorType: ${value}`);
-  }
-}
-var registry = /* @__PURE__ */ new Map();
-function assertActionId(actionId) {
-  if (!/^[a-z][a-z0-9-]*\.[a-z][a-z0-9_]*$/.test(actionId)) {
-    throw new Error(`Invalid action ID: ${actionId}`);
-  }
-}
-function registerAction(definition) {
-  assertActionId(definition.actionId);
-  if (registry.has(definition.actionId)) {
-    throw new Error(`Action "${definition.actionId}" is already registered`);
-  }
-  if (definition.mutatesDomain && definition.emitsEvents.length === 0) {
-    throw new Error(
-      `Action "${definition.actionId}" mutates domain but emits no events. Every mutating action must emit at least one AssetEvent.`
-    );
-  }
-  registry.set(definition.actionId, definition);
-}
-function resolveAction(actionId) {
-  return registry.get(actionId);
-}
-function isRegisteredActionId(actionId) {
-  return registry.has(actionId);
-}
-function resolveRegisteredAction(actionId) {
-  if (!isRegisteredActionId(actionId)) {
-    return void 0;
-  }
-  return resolveAction(actionId);
-}
-function getRegisteredActionIds() {
-  return Array.from(registry.keys());
-}
-function registerActionIfMissing(definition) {
-  if (!registry.has(definition.actionId)) {
-    registerAction(definition);
-  }
-}
-
-// adapters/index.ts
-function adapterKey(adapterType, operation) {
-  return `${adapterType}:${operation}`;
-}
-var MissingAdapterRegistrationError = class extends Error {
-  constructor(adapterType, operation) {
-    super(`No adapter registered for adapterType "${adapterType}" and operation "${operation}"`);
-    this.name = "MissingAdapterRegistrationError";
-  }
-};
-var AdapterRegistry = class {
-  adapters = /* @__PURE__ */ new Map();
-  register(adapter) {
-    const key = adapterKey(adapter.adapterType, adapter.operation);
-    if (this.adapters.has(key)) {
-      throw new Error(
-        `Adapter already registered for adapterType "${adapter.adapterType}" and operation "${adapter.operation}"`
-      );
-    }
-    this.adapters.set(key, adapter);
-  }
-  resolve(adapterType, operation) {
-    return this.adapters.get(adapterKey(adapterType, operation));
-  }
-  require(adapterType, operation) {
-    const adapter = this.resolve(adapterType, operation);
-    if (!adapter) {
-      throw new MissingAdapterRegistrationError(adapterType, operation);
-    }
-    return adapter;
-  }
-};
-var DEFAULT_RETRY_POLICY = {
-  maxAttempts: 3,
-  initialDelayMs: 100,
-  backoffMultiplier: 2,
-  maxDelayMs: 1e3
-};
-var NO_RETRY_POLICY = {
-  idempotent: false,
-  maxAttempts: 1,
-  initialDelayMs: 0,
-  backoffMultiplier: 1,
-  maxDelayMs: 0
-};
-function resolveAdapterRetryPolicy(policy, defaultIdempotent) {
-  const idempotent = policy?.idempotent ?? defaultIdempotent;
-  if (!idempotent) {
-    return NO_RETRY_POLICY;
-  }
-  return {
-    idempotent: true,
-    maxAttempts: Math.max(1, Math.min(policy?.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts, 5)),
-    initialDelayMs: Math.max(0, policy?.initialDelayMs ?? DEFAULT_RETRY_POLICY.initialDelayMs),
-    backoffMultiplier: Math.max(
-      1,
-      policy?.backoffMultiplier ?? DEFAULT_RETRY_POLICY.backoffMultiplier
-    ),
-    maxDelayMs: Math.max(0, policy?.maxDelayMs ?? DEFAULT_RETRY_POLICY.maxDelayMs)
-  };
-}
-function getRetryDelayMs(attempt, policy) {
-  const exponentialDelay = policy.initialDelayMs * policy.backoffMultiplier ** Math.max(0, attempt - 1);
-  return Math.min(exponentialDelay, policy.maxDelayMs);
-}
-async function executeWithAdapterRetry(options) {
-  const policy = resolveAdapterRetryPolicy(options.policy, options.defaultIdempotent);
-  const sleep = options.sleep ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
-  let lastError;
-  for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
-    try {
-      const result = await options.execute(attempt, policy.maxAttempts);
-      if (options.isSuccessful(result)) {
-        await options.onAttempt?.({ attempt, result, willRetry: false });
-        return result;
-      }
-      lastError = options.getError(result) ?? "Adapter returned unsuccessful result";
-      const willRetry = policy.idempotent && attempt < policy.maxAttempts;
-      const nextDelayMs = willRetry ? getRetryDelayMs(attempt, policy) : void 0;
-      await options.onAttempt?.({ attempt, result, error: lastError, willRetry, nextDelayMs });
-      if (!willRetry) {
-        return result;
-      }
-      await sleep(nextDelayMs ?? 0);
-    } catch (error) {
-      lastError = error instanceof Error ? error.message : String(error);
-      const willRetry = policy.idempotent && attempt < policy.maxAttempts;
-      const nextDelayMs = willRetry ? getRetryDelayMs(attempt, policy) : void 0;
-      await options.onAttempt?.({ attempt, error: lastError, willRetry, nextDelayMs });
-      if (!willRetry) {
-        throw error;
-      }
-      await sleep(nextDelayMs ?? 0);
-    }
-  }
-  throw new Error(lastError ?? "Adapter retry exhausted");
-}
-
-// events/index.ts
-var subjectTypeRegistry = /* @__PURE__ */ new Set([
-  "ActionInvocation",
-  "PolicyEvaluation",
-  "AdapterInvocation"
-]);
-var eventTypeRegistry = /* @__PURE__ */ new Set([
-  "ComplianceBlocked",
-  "StateTransitioned",
-  "AdapterInvocationStarted",
-  "AdapterInvocationSucceeded",
-  "AdapterInvocationFailed",
-  "WebhookReceived"
-]);
-var dynamicSubjectTypes = /* @__PURE__ */ new Set();
-var dynamicEventTypes = /* @__PURE__ */ new Set();
-function registerSubjectType(type) {
-  dynamicSubjectTypes.add(type);
-}
-function isValidSubjectType(type) {
-  return subjectTypeRegistry.has(type) || dynamicSubjectTypes.has(type);
-}
-function getRegisteredSubjectTypes() {
-  return Array.from(/* @__PURE__ */ new Set([...subjectTypeRegistry, ...dynamicSubjectTypes]));
-}
-function registerEventType(type) {
-  dynamicEventTypes.add(type);
-}
-function isValidEventType(type) {
-  return eventTypeRegistry.has(type) || dynamicEventTypes.has(type);
-}
-function getRegisteredEventTypes() {
-  return Array.from(/* @__PURE__ */ new Set([...eventTypeRegistry, ...dynamicEventTypes]));
-}
-function createEventTypeRegistry(initialEventTypes = []) {
-  const eventTypes = new Set(initialEventTypes);
-  return {
-    register(eventType) {
-      if (!eventType) {
-        throw new Error("Event type cannot be empty");
-      }
-      eventTypes.add(eventType);
-    },
-    has(eventType) {
-      return eventTypes.has(eventType);
-    },
-    list() {
-      return Array.from(eventTypes).sort();
-    }
-  };
-}
-
-// ids/index.ts
-var CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var FABRIC_ID_PREFIXES = {
-  assetEvent: "evt",
-  actionInvocation: "act",
-  policyEvaluation: "pol",
-  adapterInvocation: "adp",
-  adapterDeadLetterQueue: "dlq",
-  accessEvent: "acc",
-  projectionSnapshot: "psn",
-  complianceEvidencePacket: "cep"
-};
-var ID_REGEX = /^([a-z][a-z0-9]{1,7})_([0-9A-Z]{26})$/;
-function randomBase32(length) {
-  let output = "";
-  const randomValues = new Uint8Array(length);
-  globalThis.crypto.getRandomValues(randomValues);
-  for (const value of randomValues) {
-    output += CROCKFORD_BASE32[value % CROCKFORD_BASE32.length];
-  }
-  return output;
-}
-function createSortableRandomId() {
-  let timestamp = Date.now();
-  let encodedTime = "";
-  for (let index = 0; index < 10; index++) {
-    encodedTime = CROCKFORD_BASE32[timestamp % 32] + encodedTime;
-    timestamp = Math.floor(timestamp / 32);
-  }
-  return `${encodedTime}${randomBase32(16)}`;
-}
-function createFabricId(prefix) {
-  if (!/^[a-z][a-z0-9]{1,7}$/.test(prefix)) {
-    throw new Error(`Invalid Fabric ID prefix: ${prefix}`);
-  }
-  return `${prefix}_${createSortableRandomId()}`;
-}
-function isFabricId(id, prefix) {
-  const match = ID_REGEX.exec(id);
-  if (!match) {
-    return false;
-  }
-  return prefix ? match[1] === prefix : true;
-}
-function parseFabricId(id) {
-  const match = ID_REGEX.exec(id);
-  if (!match) {
-    return null;
-  }
-  return { prefix: match[1], ulid: match[2] };
-}
-var registry2 = /* @__PURE__ */ new Map();
-function registerDisplayRenderer(eventType, renderer) {
-  registry2.set(eventType, renderer);
-}
-function resolveDisplayRenderer(eventType) {
-  return registry2.get(eventType);
-}
-function denormalizeDisplaySnapshot(payload) {
-  if (payload !== null && typeof payload === "object" && "_displaySnapshot" in payload && payload._displaySnapshot !== null && typeof payload._displaySnapshot === "object" && "title" in payload._displaySnapshot) {
-    return payload._displaySnapshot;
-  }
-  if (payload !== null && typeof payload === "object" && "_projectionSnapshot" in payload && payload._projectionSnapshot !== null && typeof payload._projectionSnapshot === "object" && "display" in payload._projectionSnapshot && payload._projectionSnapshot.display !== null && typeof payload._projectionSnapshot.display === "object" && "title" in payload._projectionSnapshot.display) {
-    const snapshot = payload._projectionSnapshot;
-    return {
-      ...snapshot.display,
-      _cachedDisplay: {
-        source: "projection_snapshot",
-        cursor: snapshot.eventCursor,
-        checksum: snapshot.checksum,
-        generatedAt: snapshot.updatedAt
-      }
-    };
-  }
-  return void 0;
-}
-async function renderEventDisplay(eventType, payload, ctx) {
-  const snapshot = denormalizeDisplaySnapshot(payload);
-  if (snapshot) {
-    return snapshot;
-  }
-  const renderer = resolveDisplayRenderer(eventType);
-  if (!renderer) {
-    return {
-      title: eventType,
-      subtitle: "No display renderer registered for this event type."
-    };
-  }
-  return await renderer(payload, ctx);
-}
-async function _runInlineTests() {
-  const testEventType = "__TestEvent__";
-  registerDisplayRenderer(testEventType, (payload) => ({
-    title: `Test: ${payload.name}`,
-    subtitle: "registered renderer"
-  }));
-  const renderer = resolveDisplayRenderer(testEventType);
-  assert.ok(renderer, "resolveDisplayRenderer should return the registered renderer");
-  const result = await renderEventDisplay(testEventType, { name: "Alice" });
-  assert.strictEqual(result.title, "Test: Alice");
-  assert.strictEqual(result.subtitle, "registered renderer");
-  const snapshot = {
-    title: "Snapshot Title",
-    subtitle: "snapshot subtitle",
-    stateLabel: "archived",
-    primaryFacts: [{ label: "ID", value: "123" }]
-  };
-  const snapshotResult = await renderEventDisplay(testEventType, {
-    _displaySnapshot: snapshot
-  });
-  assert.deepStrictEqual(snapshotResult, snapshot);
-  const fallback = await renderEventDisplay("__UnknownEvent__", {});
-  assert.strictEqual(fallback.title, "__UnknownEvent__");
-  assert.strictEqual(fallback.subtitle, "No display renderer registered for this event type.");
-  registerDisplayRenderer("__AsyncEvent__", async (_payload, ctx) => {
-    return {
-      title: `Async: ${ctx?.tenantId ?? "no-ctx"}`
-    };
-  });
-  const asyncResult = await renderEventDisplay(
-    "__AsyncEvent__",
-    {},
-    { tenantId: "t-1", spaceId: "s-1", db: {} }
-  );
-  assert.strictEqual(asyncResult.title, "Async: t-1");
-  console.log("\u2705 display engine inline tests passed");
-}
-if (import.meta.url === `file://${process.argv[1]}`) {
-  _runInlineTests().catch((err) => {
-    console.error("\u274C display engine inline tests failed", err);
-    process.exit(1);
-  });
-}
-
-// objects/index.ts
-var objectTypeRegistry = /* @__PURE__ */ new Set([
-  "AssetEvent",
-  "ActionInvocation",
-  "PolicyEvaluation",
-  "ApprovalRequest",
-  "ConsentRecord",
-  "AgentRun"
-]);
-function assertObjectType(type) {
-  if (!/^[A-Z][a-zA-Z0-9]*$/.test(type)) {
-    throw new Error(
-      `Invalid object type: "${type}". Object types must be PascalCase alphanumeric.`
-    );
-  }
-}
-function registerObjectType(type) {
-  assertObjectType(type);
-  objectTypeRegistry.add(type);
-}
-function isValidObjectType(type) {
-  return objectTypeRegistry.has(type);
-}
-function getRegisteredObjectTypes() {
-  return Array.from(objectTypeRegistry);
-}
-
-// policies/index.ts
-function assertPolicyId(policyId) {
-  if (!/^[a-z][a-z0-9_-]*(\.[a-z][a-z0-9_-]*)*\.v[0-9]+$/.test(policyId)) {
-    throw new Error(`Invalid policy ID: ${policyId}`);
-  }
-}
-var DATA_POLICY_MAX_DEPTH = 5;
-var DATA_POLICY_MAX_CONDITIONS_PER_NODE = 20;
-var DATA_POLICY_MAX_TOTAL_CONDITIONS = 100;
-var DATA_POLICY_MAX_PATH_SEGMENTS = 12;
-var DATA_POLICY_MAX_STRING_LENGTH = 500;
-var DATA_POLICY_CONTEXT_PATHS = /* @__PURE__ */ new Set([
-  "tenantId",
-  "spaceId",
-  "actionInvocationId",
-  "actionId",
-  "mode"
-]);
-var DATA_POLICY_COMPARISON_OPERATORS = /* @__PURE__ */ new Set([
-  "exists",
-  "equals",
-  "notEquals",
-  "gt",
-  "gte",
-  "lt",
-  "lte"
-]);
-var POLICY_RESULTS = /* @__PURE__ */ new Set(["pass", "warn", "block"]);
-var registry3 = /* @__PURE__ */ new Map();
-function registerPolicy(evaluator) {
-  assertPolicyId(evaluator.policyId);
-  const existing = registry3.get(evaluator.policyId);
-  if (existing && existing !== evaluator) {
-    throw new Error(
-      `Conflicting policy registration for "${evaluator.policyId}". A different evaluator is already registered.`
-    );
-  }
-  registry3.set(evaluator.policyId, evaluator);
-}
-function registerPolicyIfMissing(evaluator) {
-  if (!registry3.has(evaluator.policyId)) {
-    registerPolicy(evaluator);
-    return;
-  }
-  const existing = registry3.get(evaluator.policyId);
-  if (existing && existing !== evaluator) {
-    throw new Error(
-      `Conflicting policy registration for "${evaluator.policyId}". A different evaluator is already registered.`
-    );
-  }
-}
-function resolvePolicy(policyId) {
-  return registry3.get(policyId);
-}
-function getRegisteredPolicyIds() {
-  return Array.from(registry3.keys());
-}
-async function evaluateRegisteredPolicies(policyIds, ctx) {
-  return evaluatePolicyDefinitions(
-    policyIds.map((policyId) => ({
-      policyId,
-      policyVersion: parsePolicyVersion(policyId),
-      kind: "code",
-      codeEvaluatorPolicyId: policyId
-    })),
-    ctx
-  );
-}
-async function evaluatePolicyDefinitions(policies, ctx) {
-  const outcomes = [];
-  for (const policy of policies) {
-    assertPolicyId(policy.policyId);
-    outcomes.push(await evaluatePolicyDefinition(policy, ctx));
-  }
-  return outcomes;
-}
-async function evaluatePolicyDefinition(policy, ctx) {
-  if (policy.kind === "data") {
-    return evaluateDataPolicy(policy, ctx);
-  }
-  if (policy.kind === "code") {
-    return evaluateCodePolicy(policy, ctx);
-  }
-  return evaluateHybridPolicy(policy, ctx);
-}
-async function evaluateCodePolicy(policy, ctx) {
-  const codeEvaluatorPolicyId = policy.codeEvaluatorPolicyId ?? policy.policyId;
-  const evaluator = registry3.get(codeEvaluatorPolicyId);
-  if (!evaluator) {
-    return {
-      policyId: policy.policyId,
-      policyVersion: policy.policyVersion,
-      policyKind: policy.kind,
-      result: "block",
-      reason: `No evaluator registered for policy ${codeEvaluatorPolicyId}`,
-      metadata: {
-        missingCodeEvaluatorPolicyId: codeEvaluatorPolicyId
-      },
-      dispatchEvidence: {
-        policyKind: policy.kind,
-        policyId: policy.policyId,
-        policyVersion: policy.policyVersion,
-        dispatchPath: ["code"],
-        code: {
-          requestedPolicyId: codeEvaluatorPolicyId,
-          policyId: codeEvaluatorPolicyId,
-          registered: false
-        }
-      }
-    };
-  }
-  const outcome = await evaluator.evaluate(ctx);
-  return normalizeOutcome(policy, outcome, {
-    policyKind: policy.kind,
-    policyId: policy.policyId,
-    policyVersion: policy.policyVersion,
-    dispatchPath: ["code"],
-    code: {
-      requestedPolicyId: codeEvaluatorPolicyId,
-      policyId: evaluator.policyId,
-      version: evaluator.version,
-      registered: true
-    }
-  });
-}
-async function evaluateHybridPolicy(policy, ctx) {
-  const dataOutcome = evaluateDataPolicy(policy, ctx);
-  const fallback = policy.fallback;
-  const fallbackDecision = fallback ? resolveFallbackDecision(policy, dataOutcome, fallback) : { shouldFallback: false, trigger: "not_triggered" };
-  if (!fallback || !fallbackDecision.shouldFallback) {
-    if (fallback && dataOutcome.dispatchEvidence) {
-      return {
-        ...dataOutcome,
-        dispatchEvidence: {
-          ...dataOutcome.dispatchEvidence,
-          fallback: {
-            used: false,
-            trigger: "not_triggered",
-            reason: "Data policy result did not trigger fallback",
-            fromResult: dataOutcome.result,
-            definitionVersion: policy.policyVersion,
-            codeEvaluatorPolicyId: fallback.codeEvaluatorPolicyId
-          }
-        }
-      };
-    }
-    return dataOutcome;
-  }
-  const codePolicy = {
-    policyId: policy.policyId,
-    policyVersion: policy.policyVersion,
-    kind: "hybrid",
-    codeEvaluatorPolicyId: fallback.codeEvaluatorPolicyId
-  };
-  const codeOutcome = await evaluateCodePolicy(codePolicy, ctx);
-  return normalizeOutcome(policy, codeOutcome, {
-    ...codeOutcome.dispatchEvidence ?? {
-      policyKind: "hybrid",
-      policyId: policy.policyId,
-      policyVersion: policy.policyVersion,
-      dispatchPath: ["code"]
-    },
-    policyKind: "hybrid",
-    policyId: policy.policyId,
-    policyVersion: policy.policyVersion,
-    dispatchPath: ["data", "fallback", "code"],
-    data: dataOutcome.dispatchEvidence?.data,
-    fallback: {
-      used: true,
-      trigger: fallbackDecision.trigger,
-      reason: fallback.reason ?? "Data policy result triggered code fallback",
-      fromResult: dataOutcome.result,
-      definitionVersion: policy.policyVersion,
-      codeEvaluatorPolicyId: fallback.codeEvaluatorPolicyId
-    }
-  });
-}
-function resolveFallbackDecision(policy, dataOutcome, fallback) {
-  const allowedTriggers = fallback.triggers ?? [
-    "data_result",
-    "missing_data_definition",
-    "invalid_data_definition"
-  ];
-  const definitionStatus = dataOutcome.dispatchEvidence?.data?.definitionStatus;
-  if (definitionStatus === "missing") {
-    return {
-      shouldFallback: allowedTriggers.includes("missing_data_definition"),
-      trigger: "missing_data_definition"
-    };
-  }
-  if (definitionStatus === "invalid") {
-    return {
-      shouldFallback: allowedTriggers.includes("invalid_data_definition"),
-      trigger: "invalid_data_definition"
-    };
-  }
-  const fallbackResults = fallback.onResults ?? ["warn", "block"];
-  return {
-    shouldFallback: policy.kind === "hybrid" && allowedTriggers.includes("data_result") && fallbackResults.includes(dataOutcome.result),
-    trigger: "data_result"
-  };
-}
-function evaluateDataPolicy(policy, ctx) {
-  const definition = policy.dataDefinition;
-  if (!definition) {
-    return {
-      policyId: policy.policyId,
-      policyVersion: policy.policyVersion,
-      policyKind: policy.kind,
-      result: "block",
-      reason: "Data policy definition is missing",
-      dispatchEvidence: {
-        policyKind: policy.kind,
-        policyId: policy.policyId,
-        policyVersion: policy.policyVersion,
-        dispatchPath: ["data"],
-        data: {
-          definitionVersion: policy.policyVersion,
-          definitionStatus: "missing",
-          conditionResults: []
-        }
-      }
-    };
-  }
-  const validation = validateDataPolicyDefinition(definition);
-  if (!validation.valid) {
-    return {
-      policyId: policy.policyId,
-      policyVersion: policy.policyVersion,
-      policyKind: policy.kind,
-      result: "block",
-      reason: `Invalid data policy definition: ${validation.errors.join("; ")}`,
-      metadata: {
-        validationErrors: validation.errors
-      },
-      dispatchEvidence: {
-        policyKind: policy.kind,
-        policyId: policy.policyId,
-        policyVersion: policy.policyVersion,
-        dispatchPath: ["data"],
-        data: {
-          definitionVersion: policy.policyVersion,
-          definitionStatus: "invalid",
-          conditionResults: [],
-          validationErrors: validation.errors
-        }
-      }
-    };
-  }
-  const evaluations = definition.conditions.map((condition) => evaluateDataPolicyCondition(condition, ctx));
-  const conditionResults = evaluations.flatMap((evaluation) => evaluation.evidence);
-  const topLevelResults = evaluations.map((evaluation) => evaluation.result);
-  const aggregate = topLevelResults.find((result2) => result2.result === "block") ?? topLevelResults.find((result2) => result2.result === "warn");
-  const result = aggregate?.result ?? definition.defaultResult ?? "pass";
-  return {
-    policyId: policy.policyId,
-    policyVersion: policy.policyVersion,
-    policyKind: policy.kind,
-    result,
-    reason: aggregate?.reason ?? definition.reason,
-    metadata: {
-      conditionCount: definition.conditions.length,
-      failedConditionId: aggregate?.conditionId
-    },
-    dispatchEvidence: {
-      policyKind: policy.kind,
-      policyId: policy.policyId,
-      policyVersion: policy.policyVersion,
-      dispatchPath: ["data"],
-      data: {
-        definitionVersion: policy.policyVersion,
-        definitionStatus: "evaluated",
-        conditionResults
-      }
-    }
-  };
-}
-function validateDataPolicyDefinition(definition) {
-  const errors = [];
-  if (!Array.isArray(definition.conditions) || definition.conditions.length === 0) {
-    errors.push("conditions must contain at least one condition");
-  } else if (definition.conditions.length > DATA_POLICY_MAX_CONDITIONS_PER_NODE) {
-    errors.push(
-      `conditions must contain at most ${DATA_POLICY_MAX_CONDITIONS_PER_NODE} top-level conditions`
-    );
-  }
-  if (definition.defaultResult && !POLICY_RESULTS.has(definition.defaultResult)) {
-    errors.push("defaultResult must be pass, warn, or block");
-  }
-  let totalConditions = 0;
-  for (const condition of definition.conditions ?? []) {
-    validateDataPolicyCondition(condition, errors, 1, () => {
-      totalConditions += 1;
-    });
-  }
-  if (totalConditions > DATA_POLICY_MAX_TOTAL_CONDITIONS) {
-    errors.push(`policy must contain at most ${DATA_POLICY_MAX_TOTAL_CONDITIONS} total conditions`);
-  }
-  return { valid: errors.length === 0, errors };
-}
-function validateDataPolicyCondition(condition, errors, depth, count) {
-  count();
-  if (!condition || typeof condition !== "object") {
-    errors.push("condition must be an object");
-    return;
-  }
-  if (depth > DATA_POLICY_MAX_DEPTH) {
-    errors.push(`condition depth must not exceed ${DATA_POLICY_MAX_DEPTH}`);
-    return;
-  }
-  if (!isNonEmptyBoundedString(condition.conditionId)) {
-    errors.push("conditionId must be a non-empty bounded string");
-  }
-  validateOptionalPolicyResult("onPass" in condition ? condition.onPass : void 0, "onPass", errors);
-  validateOptionalPolicyResult("onFail" in condition ? condition.onFail : void 0, "onFail", errors);
-  if (condition.reason !== void 0 && !isNonEmptyBoundedString(condition.reason)) {
-    errors.push(`condition ${condition.conditionId} reason must be a bounded string`);
-  }
-  if (condition.type === "always") {
-    if (!POLICY_RESULTS.has(condition.result)) {
-      errors.push(`condition ${condition.conditionId} result must be pass, warn, or block`);
-    }
-    return;
-  }
-  if (condition.type === "parameter") {
-    validatePath(condition.path, `condition ${condition.conditionId} path`, errors);
-    validateComparison(condition.operator, condition.value, condition.conditionId, errors);
-    return;
-  }
-  if (condition.type === "comparison") {
-    validateSourceReference(condition.left, condition.conditionId, errors);
-    validateComparison(condition.operator, condition.value, condition.conditionId, errors);
-    return;
-  }
-  if (condition.type === "all" || condition.type === "any") {
-    if (!Array.isArray(condition.conditions) || condition.conditions.length === 0) {
-      errors.push(`condition ${condition.conditionId} must contain child conditions`);
-      return;
-    }
-    if (condition.conditions.length > DATA_POLICY_MAX_CONDITIONS_PER_NODE) {
-      errors.push(
-        `condition ${condition.conditionId} must contain at most ${DATA_POLICY_MAX_CONDITIONS_PER_NODE} child conditions`
-      );
-    }
-    for (const child of condition.conditions) {
-      validateDataPolicyCondition(child, errors, depth + 1, count);
-    }
-    return;
-  }
-  if (condition.type === "not") {
-    validateDataPolicyCondition(condition.condition, errors, depth + 1, count);
-    return;
-  }
-  errors.push(`condition ${condition.conditionId} has unsupported type`);
-}
-function validateOptionalPolicyResult(result, fieldName, errors) {
-  if (result !== void 0 && !POLICY_RESULTS.has(result)) {
-    errors.push(`${fieldName} must be pass, warn, or block`);
-  }
-}
-function validateSourceReference(reference, conditionId, errors) {
-  if (!reference || typeof reference !== "object") {
-    errors.push(`condition ${conditionId} left must be a source reference`);
-    return;
-  }
-  if (reference.source !== "parameters" && reference.source !== "context") {
-    errors.push(`condition ${conditionId} source must be parameters or context`);
-  }
-  validatePath(reference.path, `condition ${conditionId} left.path`, errors);
-  if (reference.source === "context" && !DATA_POLICY_CONTEXT_PATHS.has(reference.path)) {
-    errors.push(`condition ${conditionId} uses an unsupported context path`);
-  }
-}
-function validateComparison(operator, value, conditionId, errors) {
-  if (!DATA_POLICY_COMPARISON_OPERATORS.has(operator)) {
-    errors.push(`condition ${conditionId} has unsupported operator`);
-    return;
-  }
-  if (operator === "exists") {
-    return;
-  }
-  if (!isDataPolicyLiteral(value)) {
-    errors.push(`condition ${conditionId} comparison value must be a bounded literal`);
-    return;
-  }
-  if (["gt", "gte", "lt", "lte"].includes(operator) && typeof value !== "number") {
-    errors.push(`condition ${conditionId} numeric comparison requires a number value`);
-  }
-}
-function validatePath(path, fieldName, errors) {
-  if (!isNonEmptyBoundedString(path)) {
-    errors.push(`${fieldName} must be a non-empty bounded string`);
-    return;
-  }
-  const segments = path.split(".");
-  if (segments.length > DATA_POLICY_MAX_PATH_SEGMENTS) {
-    errors.push(`${fieldName} must contain at most ${DATA_POLICY_MAX_PATH_SEGMENTS} segments`);
-    return;
-  }
-  for (const segment of segments) {
-    if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(segment)) {
-      errors.push(`${fieldName} contains an invalid path segment`);
-      return;
-    }
-    if (["__proto__", "constructor", "prototype"].includes(segment)) {
-      errors.push(`${fieldName} contains a forbidden path segment`);
-      return;
-    }
-  }
-}
-function isDataPolicyLiteral(value) {
-  if (value === null || typeof value === "number" || typeof value === "boolean") {
-    return true;
-  }
-  return typeof value === "string" && value.length <= DATA_POLICY_MAX_STRING_LENGTH;
-}
-function isNonEmptyBoundedString(value) {
-  return typeof value === "string" && value.length > 0 && value.length <= DATA_POLICY_MAX_STRING_LENGTH;
-}
-function evaluateDataPolicyCondition(condition, ctx) {
-  if (condition.type === "always") {
-    const result2 = {
-      conditionId: condition.conditionId,
-      passed: condition.result === "pass",
-      result: condition.result,
-      reason: condition.reason
-    };
-    return { result: result2, evidence: [result2] };
-  }
-  if (condition.type === "all" || condition.type === "any") {
-    const childEvaluations = condition.conditions.map((child) => evaluateDataPolicyCondition(child, ctx));
-    const passed2 = condition.type === "all" ? childEvaluations.every((evaluation) => evaluation.result.passed) : childEvaluations.some((evaluation) => evaluation.result.passed);
-    const result2 = {
-      conditionId: condition.conditionId,
-      passed: passed2,
-      result: passed2 ? condition.onPass ?? "pass" : condition.onFail ?? "block",
-      reason: passed2 ? void 0 : condition.reason
-    };
-    return {
-      result: result2,
-      evidence: [result2, ...childEvaluations.flatMap((evaluation) => evaluation.evidence)]
-    };
-  }
-  if (condition.type === "not") {
-    const childEvaluation = evaluateDataPolicyCondition(condition.condition, ctx);
-    const passed2 = !childEvaluation.result.passed;
-    const result2 = {
-      conditionId: condition.conditionId,
-      passed: passed2,
-      result: passed2 ? condition.onPass ?? "pass" : condition.onFail ?? "block",
-      reason: passed2 ? void 0 : condition.reason
-    };
-    return { result: result2, evidence: [result2, ...childEvaluation.evidence] };
-  }
-  if (condition.type !== "parameter" && condition.type !== "comparison") {
-    const result2 = {
-      conditionId: condition.conditionId,
-      passed: false,
-      result: "block",
-      reason: "Unsupported data policy condition type"
-    };
-    return { result: result2, evidence: [result2] };
-  }
-  const value = condition.type === "parameter" ? readPath(ctx.parameters, condition.path) : readDataPolicySource(ctx, condition.left);
-  const operator = condition.operator;
-  const expected = condition.value;
-  const passed = evaluateOperator(value, operator, expected);
-  const result = {
-    conditionId: condition.conditionId,
-    passed,
-    result: passed ? condition.onPass ?? "pass" : condition.onFail ?? "block",
-    reason: passed ? void 0 : condition.reason
-  };
-  return { result, evidence: [result] };
-}
-function evaluateOperator(actual, operator, expected) {
-  switch (operator) {
-    case "exists":
-      return actual !== void 0 && actual !== null && actual !== "";
-    case "equals":
-      return actual === expected;
-    case "notEquals":
-      return actual !== expected;
-    case "gt":
-      return typeof actual === "number" && typeof expected === "number" && actual > expected;
-    case "gte":
-      return typeof actual === "number" && typeof expected === "number" && actual >= expected;
-    case "lt":
-      return typeof actual === "number" && typeof expected === "number" && actual < expected;
-    case "lte":
-      return typeof actual === "number" && typeof expected === "number" && actual <= expected;
-  }
-}
-function readDataPolicySource(ctx, reference) {
-  if (reference.source === "parameters") {
-    return readPath(ctx.parameters, reference.path);
-  }
-  return readPath(
-    {
-      tenantId: ctx.tenantId,
-      spaceId: ctx.spaceId,
-      actionInvocationId: ctx.actionInvocationId,
-      actionId: ctx.actionId,
-      mode: ctx.mode
-    },
-    reference.path
-  );
-}
-function readPath(source, path) {
-  if (!source || typeof source !== "object") {
-    return void 0;
-  }
-  return path.split(".").reduce((current, segment) => {
-    if (!current || typeof current !== "object") {
-      return void 0;
-    }
-    return current[segment];
-  }, source);
-}
-function normalizeOutcome(policy, outcome, dispatchEvidence) {
-  return {
-    ...outcome,
-    policyId: policy.policyId,
-    policyVersion: policy.policyVersion,
-    policyKind: policy.kind,
-    metadata: {
-      ...outcome.metadata ?? {},
-      codePolicyId: dispatchEvidence.code?.policyId ?? outcome.policyId,
-      codePolicyVersion: dispatchEvidence.code?.version ?? outcome.policyVersion
-    },
-    dispatchEvidence
-  };
-}
-function parsePolicyVersion(policyId) {
-  const segments = policyId.split(".v");
-  return Number(segments[segments.length - 1] ?? 1);
-}
-function aggregatePolicyOutcomes(outcomes) {
-  return outcomes.find((outcome) => outcome.result === "block") ?? outcomes.find((outcome) => outcome.result === "warn");
-}
-
-// state-machines/engine.ts
-var registry4 = /* @__PURE__ */ new Map();
-function registerStateMachine(def) {
-  if (registry4.has(def.entityType)) {
-    throw new Error(`State machine for entity type "${def.entityType}" is already registered.`);
-  }
-  registry4.set(def.entityType, def);
-}
-function registerStateMachineIfMissing(def) {
-  if (!registry4.has(def.entityType)) {
-    registerStateMachine(def);
-  }
-}
-function resolveStateMachine(entityType) {
-  return registry4.get(entityType);
-}
-function validateTransition(entityType, from, to, actionId) {
-  const sm = registry4.get(entityType);
-  if (!sm) {
-    return {
-      valid: false,
-      error: `No state machine registered for entity type "${entityType}".`
-    };
-  }
-  const fromDef = sm.states[from];
-  if (!fromDef) {
-    return {
-      valid: false,
-      error: `State "${from}" does not exist in state machine for entity type "${entityType}".`
-    };
-  }
-  const toDef = sm.states[to];
-  if (!toDef) {
-    return {
-      valid: false,
-      error: `State "${to}" does not exist in state machine for entity type "${entityType}".`
-    };
-  }
-  const transitionExists = sm.transitions.some(
-    (t) => t.from === from && t.to === to && t.causedByAction === actionId
-  );
-  if (!transitionExists) {
-    return {
-      valid: false,
-      error: `Transition from "${from}" to "${to}" via action "${actionId}" is not defined for entity type "${entityType}".`
-    };
-  }
-  return { valid: true };
-}
-function getAllowedTransitions(entityType, from) {
-  const sm = registry4.get(entityType);
-  if (!sm) {
-    return [];
-  }
-  return sm.transitions.filter((t) => t.from === from).map((t) => ({ to: t.to, causedByAction: t.causedByAction }));
-}
-function getEntityStateClass(entityType, state) {
-  const sm = registry4.get(entityType);
-  if (!sm) {
-    return void 0;
-  }
-  return sm.states[state]?.stateClass;
-}
-
-// modules/index.ts
-var registeredModuleNamespaces = /* @__PURE__ */ new Set();
-function getModuleDependencyNamespace(dependency) {
-  return typeof dependency === "string" ? dependency : dependency.namespace;
-}
-function getObjectTypeName(objectType) {
-  return typeof objectType === "string" ? objectType : objectType.type;
-}
-function getEventTypeName(eventType) {
-  return typeof eventType === "string" ? eventType : eventType.eventType;
-}
-function validateModuleNamespace(namespace) {
-  if (!namespace) {
-    throw new Error("Module namespace cannot be empty");
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(namespace)) {
-    throw new Error(
-      `Invalid module namespace: "${namespace}". Must be lowercase letters, numbers, and hyphens only.`
-    );
-  }
-}
-function createModuleRegistry(modules = []) {
-  const registered = /* @__PURE__ */ new Map();
-  for (const module of modules) {
-    validateModuleNamespace(module.namespace);
-    if (registered.has(module.namespace)) {
-      throw new Error(`Duplicate FabricModule namespace "${module.namespace}".`);
-    }
-    registered.set(module.namespace, module);
-  }
-  return { modules: registered };
-}
-function validateIdentifierList(values, label, namespace) {
-  for (const value of values ?? []) {
-    if (!value) {
-      throw new Error(`Module "${namespace}" has an empty ${label} entry.`);
-    }
-  }
-}
-function validateManifest(module, context = {}) {
-  validateModuleNamespace(module.namespace);
-  const dependencies = (module.dependencies ?? []).map(getModuleDependencyNamespace);
-  const objectTypes = (module.objectTypes ?? []).map(getObjectTypeName);
-  const eventTypes = (module.eventTypes ?? []).map(getEventTypeName);
-  for (const dependency of dependencies) {
-    validateModuleNamespace(dependency);
-    if (dependency === module.namespace) {
-      throw new Error(`Module "${module.namespace}" cannot depend on itself.`);
-    }
-    if (context.availableNamespaces && !context.availableNamespaces.has(dependency)) {
-      throw new Error(`Module "${module.namespace}" depends on missing module "${dependency}".`);
-    }
-  }
-  validateIdentifierList(objectTypes, "objectTypes", module.namespace);
-  validateIdentifierList(module.subjectTypes, "subjectTypes", module.namespace);
-  validateIdentifierList(eventTypes, "eventTypes", module.namespace);
-  for (const objectType of objectTypes) {
-    if (!/^[A-Z][a-zA-Z0-9]*$/.test(objectType)) {
-      throw new Error(
-        `Invalid object type: "${objectType}". Object types must be PascalCase alphanumeric.`
-      );
-    }
-  }
-  for (const action of module.actions ?? []) {
-    if (!/^[a-z][a-z0-9-]*\.[a-z][a-z0-9_]*$/.test(action.actionId)) {
-      throw new Error(`Invalid action ID: ${action.actionId}`);
-    }
-    if (action.namespace !== module.namespace) {
-      throw new Error(
-        `Action "${action.actionId}" declares namespace "${action.namespace}" but is registered by module "${module.namespace}".`
-      );
-    }
-    if (!action.actionId.startsWith(`${module.namespace}.`)) {
-      throw new Error(
-        `Action "${action.actionId}" must start with module namespace "${module.namespace}."`
-      );
-    }
-    if (action.mutatesDomain && action.emitsEvents.length === 0) {
-      throw new Error(
-        `Action "${action.actionId}" mutates domain but emits no events. Every mutating action must emit at least one AssetEvent.`
-      );
-    }
-  }
-  for (const descriptor of module.displayRenderers ?? []) {
-    const isPlannedEventType = context.plannedEventTypes?.has(descriptor.eventType) ?? false;
-    const isModuleEventType = eventTypes.includes(descriptor.eventType);
-    if (!isValidEventType(descriptor.eventType) && !isModuleEventType && !isPlannedEventType) {
-      throw new Error(
-        `Display renderer registered for unknown event type "${descriptor.eventType}". Register the event type before adding a display renderer.`
-      );
-    }
-  }
-}
-function sortModulesByDependency(modules, registeredNamespaces = registeredModuleNamespaces) {
-  const modulesByNamespace = /* @__PURE__ */ new Map();
-  for (const module of modules) {
-    validateModuleNamespace(module.namespace);
-    if (modulesByNamespace.has(module.namespace)) {
-      throw new Error(`Duplicate Fabric module namespace "${module.namespace}".`);
-    }
-    modulesByNamespace.set(module.namespace, module);
-  }
-  const sorted = [];
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  function visit(module, path) {
-    if (visited.has(module.namespace)) {
-      return;
-    }
-    if (visiting.has(module.namespace)) {
-      throw new Error(
-        `Cyclic Fabric module dependency detected: ${[...path, module.namespace].join(" -> ")}`
-      );
-    }
-    visiting.add(module.namespace);
-    for (const dependency of (module.dependencies ?? []).map(getModuleDependencyNamespace)) {
-      const dependencyModule = modulesByNamespace.get(dependency);
-      if (!dependencyModule) {
-        if (registeredNamespaces.has(dependency)) {
-          continue;
-        }
-        throw new Error(`Module "${module.namespace}" depends on missing module "${dependency}".`);
-      }
-      visit(dependencyModule, [...path, module.namespace]);
-    }
-    visiting.delete(module.namespace);
-    visited.add(module.namespace);
-    sorted.push(module);
-  }
-  for (const module of modules) {
-    visit(module, []);
-  }
-  return sorted;
-}
-function registerFabricModule(module) {
-  validateManifest(module, { availableNamespaces: registeredModuleNamespaces });
-  for (const objectType of module.objectTypes ?? []) {
-    registerObjectType(getObjectTypeName(objectType));
-  }
-  for (const subjectType of module.subjectTypes ?? []) {
-    registerSubjectType(subjectType);
-  }
-  for (const eventType of module.eventTypes ?? []) {
-    registerEventType(getEventTypeName(eventType));
-  }
-  for (const policy of module.policies ?? []) {
-    registerPolicyIfMissing(policy);
-  }
-  for (const machine of module.stateMachines ?? []) {
-    registerStateMachineIfMissing(machine);
-  }
-  for (const action of module.actions ?? []) {
-    registerActionIfMissing(action);
-  }
-  for (const descriptor of module.displayRenderers ?? []) {
-    registerDisplayRenderer(descriptor.eventType, descriptor.renderer);
-  }
-  registeredModuleNamespaces.add(module.namespace);
-}
-function registerFabricModules(modules) {
-  const availableNamespaces = /* @__PURE__ */ new Set([
-    ...registeredModuleNamespaces,
-    ...modules.map((module) => module.namespace)
-  ]);
-  const plannedEventTypes = new Set(
-    modules.flatMap((module) => (module.eventTypes ?? []).map(getEventTypeName))
-  );
-  for (const module of modules) {
-    validateManifest(module, { availableNamespaces, plannedEventTypes });
-  }
-  const sortedModules = sortModulesByDependency(modules);
-  for (const module of sortedModules) {
-    registerFabricModule(module);
-  }
-  return sortedModules;
-}
-
-// projections/index.ts
-async function replayEvents({
-  events,
-  scope,
-  initialState,
-  snapshot,
-  applyEvent
-}) {
-  const warnings = [];
-  const scopedEvents = filterEventsByScope(await collectEvents(events), scope, warnings);
-  const orderedEvents = sortEvents(scopedEvents, isSubjectScoped(scope));
-  const uniqueEvents = removeDuplicateEvents(orderedEvents, warnings);
-  const resumableEvents = applyCursor(uniqueEvents, snapshot, isSubjectScoped(scope), warnings);
-  let state = snapshot?.snapshotData ?? initialState;
-  const appliedEvents = [];
-  let eventCursor = snapshot?.eventCursor ?? null;
-  let eventSequence = snapshot?.eventSequence ?? 0;
-  for (const event of resumableEvents) {
-    state = await applyEvent(state, event);
-    appliedEvents.push(event);
-    eventCursor = event.id;
-    eventSequence = event.sequence;
-  }
-  return {
-    state,
-    appliedEvents,
-    warnings,
-    eventCursor,
-    eventSequence
-  };
-}
-async function collectEvents(events) {
-  const collected = [];
-  if (Symbol.asyncIterator in events) {
-    for await (const event of events) {
-      collected.push(event);
-    }
-    return collected;
-  }
-  for (const event of events) {
-    collected.push(event);
-  }
-  return collected;
-}
-function filterEventsByScope(events, scope, warnings) {
-  if (scope.subjectType && !scope.subjectId || !scope.subjectType && scope.subjectId) {
-    warnings.push({
-      code: "subject_scope_incomplete",
-      message: "Both subjectType and subjectId are required for subject-scoped replay.",
-      subjectType: scope.subjectType,
-      subjectId: scope.subjectId
-    });
-  }
-  return events.filter((event) => {
-    if (event.tenantId !== scope.tenantId || event.spaceId !== scope.spaceId) {
-      return false;
-    }
-    if (scope.subjectType && event.subjectType !== scope.subjectType) {
-      return false;
-    }
-    if (scope.subjectId && event.subjectId !== scope.subjectId) {
-      return false;
-    }
-    return true;
-  });
-}
-function removeDuplicateEvents(events, warnings) {
-  const seenEventIds = /* @__PURE__ */ new Set();
-  const uniqueEvents = [];
-  for (const event of events) {
-    if (seenEventIds.has(event.id)) {
-      warnings.push({
-        code: "duplicate_event",
-        message: `Duplicate event ${event.id} ignored during replay.`,
-        eventId: event.id,
-        subjectType: event.subjectType,
-        subjectId: event.subjectId
-      });
-      continue;
-    }
-    seenEventIds.add(event.id);
-    uniqueEvents.push(event);
-  }
-  recordMissingSequenceWarnings(uniqueEvents, warnings);
-  return uniqueEvents;
-}
-function recordMissingSequenceWarnings(events, warnings) {
-  const lastSequenceBySubject = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const subjectKey = `${event.subjectType}:${event.subjectId}`;
-    const previousSequence = lastSequenceBySubject.get(subjectKey);
-    const expectedSequence = previousSequence === void 0 ? event.sequence : previousSequence + 1;
-    if (previousSequence !== void 0 && event.sequence > expectedSequence) {
-      warnings.push({
-        code: "missing_sequence",
-        message: `Missing event sequence for ${subjectKey}: expected ${expectedSequence}, received ${event.sequence}.`,
-        eventId: event.id,
-        subjectType: event.subjectType,
-        subjectId: event.subjectId,
-        expectedSequence,
-        actualSequence: event.sequence
-      });
-    }
-    lastSequenceBySubject.set(subjectKey, Math.max(previousSequence ?? event.sequence, event.sequence));
-  }
-}
-function applyCursor(events, snapshot, subjectScoped, warnings) {
-  const eventCursor = snapshot?.eventCursor;
-  if (eventCursor) {
-    const cursorIndex = events.findIndex((event) => event.id === eventCursor);
-    if (cursorIndex >= 0) {
-      return events.slice(cursorIndex + 1);
-    }
-    warnings.push({
-      code: "cursor_not_found",
-      message: `Snapshot cursor ${eventCursor} was not found in the scoped event stream.`,
-      eventId: eventCursor
-    });
-  }
-  if (subjectScoped && snapshot?.eventSequence !== void 0 && snapshot.eventSequence !== null) {
-    return events.filter((event) => event.sequence > snapshot.eventSequence);
-  }
-  return events;
-}
-function sortEvents(events, subjectScoped) {
-  return [...events].sort(
-    (first, second) => subjectScoped ? compareSubjectEvents(first, second) : compareGlobalEvents(first, second)
-  );
-}
-function compareSubjectEvents(first, second) {
-  return compareValues(
-    [first.sequence, toTimestamp(first.recordedAt), toTimestamp(first.occurredAt), first.id],
-    [second.sequence, toTimestamp(second.recordedAt), toTimestamp(second.occurredAt), second.id]
-  );
-}
-function compareGlobalEvents(first, second) {
-  return compareValues(
-    [
-      toTimestamp(first.recordedAt),
-      toTimestamp(first.occurredAt),
-      first.actionInvocationId,
-      first.correlationId,
-      first.subjectType,
-      first.subjectId,
-      first.sequence,
-      first.id
-    ],
-    [
-      toTimestamp(second.recordedAt),
-      toTimestamp(second.occurredAt),
-      second.actionInvocationId,
-      second.correlationId,
-      second.subjectType,
-      second.subjectId,
-      second.sequence,
-      second.id
-    ]
-  );
-}
-function compareValues(firstValues, secondValues) {
-  for (const [index, firstValue] of firstValues.entries()) {
-    const secondValue = secondValues[index];
-    if (firstValue < secondValue) {
-      return -1;
-    }
-    if (firstValue > secondValue) {
-      return 1;
-    }
-  }
-  return 0;
-}
-function isSubjectScoped(scope) {
-  return Boolean(scope.subjectType && scope.subjectId);
-}
-function toTimestamp(value) {
-  return value instanceof Date ? value.getTime() : new Date(value).getTime();
-}
-
-// privacy/index.ts
-var PLATFORM_PRIVACY_POLICY_VERSION = "fabric-platform-privacy-v1";
-
-// testing/index.ts
-function createFakeActionContext(options = {}) {
-  return {
-    actionInvocationId: options.actionInvocationId ?? "act_test",
-    tenantId: options.tenantId ?? "tenant-test",
-    spaceId: options.spaceId ?? "space-test",
-    actorId: options.actorId ?? "actor-test",
-    actorType: options.actorType ?? "system",
-    correlationId: options.correlationId ?? "corr-test",
-    causationId: options.causationId,
-    db: options.db ?? {},
-    services: options.services ?? {}
-  };
-}
-function createInMemoryAdapterRegistry() {
-  return new AdapterRegistry();
-}
-function createDeterministicIdFactory(prefix = "test") {
-  let sequence = 0;
-  return () => `${prefix}_${String(++sequence).padStart(6, "0")}`;
-}
-
-export { ACTOR_TYPES, AdapterRegistry, FABRIC_ID_PREFIXES, MissingAdapterRegistrationError, PLATFORM_PRIVACY_POLICY_VERSION, aggregatePolicyOutcomes, assertActionId, assertActorType, assertObjectType, assertPolicyId, createDeterministicIdFactory, createEventTypeRegistry, createFabricId, createFakeActionContext, createInMemoryAdapterRegistry, createModuleRegistry, denormalizeDisplaySnapshot, evaluatePolicyDefinition, evaluatePolicyDefinitions, evaluateRegisteredPolicies, executeWithAdapterRetry, getAllowedTransitions, getEntityStateClass, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, getRegisteredActionIds, getRegisteredEventTypes, getRegisteredObjectTypes, getRegisteredPolicyIds, getRegisteredSubjectTypes, getRetryDelayMs, isActorType, isFabricId, isRegisteredActionId, isValidEventType, isValidObjectType, isValidSubjectType, parseFabricId, registerAction, registerActionIfMissing, registerDisplayRenderer, registerEventType, registerFabricModule, registerFabricModules, registerObjectType, registerPolicy, registerPolicyIfMissing, registerStateMachine, registerStateMachineIfMissing, registerSubjectType, renderEventDisplay, replayEvents, resolveAction, resolveAdapterRetryPolicy, resolveDisplayRenderer, resolvePolicy, resolveRegisteredAction, resolveStateMachine, validateDataPolicyDefinition, validateModuleNamespace, validateTransition };
+export { PLATFORM_PRIVACY_POLICY_VERSION } from './chunk-N24NLCZ6.js';
+export { replayEvents } from './chunk-JSTGOT6P.js';
+export { createDeterministicIdFactory, createFakeActionContext, createInMemoryAdapterRegistry } from './chunk-IFMZPLM4.js';
+export { AdapterRegistry, MissingAdapterRegistrationError, executeWithAdapterRetry, getRetryDelayMs, resolveAdapterRetryPolicy } from './chunk-3ZW5USXF.js';
+import './chunk-OZLZHISS.js';
+export { FABRIC_ID_PREFIXES, createFabricId, isFabricId, parseFabricId } from './chunk-RALMUSOX.js';
+export { createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace } from './chunk-PXMKCAQI.js';
+export { assertObjectType, getRegisteredObjectTypes, isValidObjectType, registerObjectType } from './chunk-I35B576X.js';
+export { aggregatePolicyOutcomes, assertPolicyId, evaluatePolicyDefinition, evaluatePolicyDefinitions, evaluateRegisteredPolicies, getRegisteredPolicyIds, registerPolicy, registerPolicyIfMissing, resolvePolicy, validateDataPolicyDefinition } from './chunk-KOC4A7A4.js';
+export { getAllowedTransitions, getEntityStateClass, registerStateMachine, registerStateMachineIfMissing, resolveStateMachine, validateTransition } from './chunk-3A6FU3KV.js';
+export { ACTOR_TYPES, assertActionId, assertActorType, getRegisteredActionIds, isActorType, isRegisteredActionId, registerAction, registerActionIfMissing, resolveAction, resolveRegisteredAction } from './chunk-6FMW4NF6.js';
+export { denormalizeDisplaySnapshot, registerDisplayRenderer, renderEventDisplay, resolveDisplayRenderer } from './chunk-3F6FKQZA.js';
+export { createEventTypeRegistry, getRegisteredEventTypes, getRegisteredSubjectTypes, isValidEventType, isValidSubjectType, registerEventType, registerSubjectType } from './chunk-4YQOGV7H.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map