@fabricorg/platform 1.9.0 → 1.10.1

package/dist/index-CVHA1ypT.d.cts

@@ -0,0 +1,262 @@
+import { ActionId, ActorType, FabricRuntimeServices } from "./actions/index.cjs";
+//#region policies/reconciliation-required.d.ts
+/** A possibly committed domain effect requiring an operator decision at the handler transaction boundary. */
+declare class ReconciliationRequiredError extends Error {
+  readonly name = "ReconciliationRequiredError";
+  readonly code: "EXECUTION_RECONCILIATION_REQUIRED";
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Recognise a ReconciliationRequiredError, including one constructed by a second
+ * package copy (for example ESM and CommonJS builds loaded side by side).
+ */
+declare function isReconciliationRequiredError(error: unknown): error is ReconciliationRequiredError;
+//#endregion
+//#region policies/retryable-execution.d.ts
+/** A transient execution dependency failure; the host decides whether retry is safe. */
+declare class RetryableExecutionError extends Error {
+  readonly name = "RetryableExecutionError";
+  readonly code: "EXECUTION_RETRYABLE";
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Recognise a RetryableExecutionError, including one constructed by a second
+ * package copy (for example ESM and CommonJS builds loaded side by side).
+ */
+declare function isRetryableExecutionError(error: unknown): error is RetryableExecutionError;
+//#endregion
+//#region policies/index.d.ts
+type PolicyEvaluationResult = "pass" | "warn" | "block";
+type PolicyKind = "code" | "data" | "hybrid";
+type PolicyId = `${string}.v${number}`;
+type PolicyEvaluationMode = "preview" | "execute";
+declare function assertPolicyId(policyId: string): asserts policyId is PolicyId;
+interface PolicyContext<TDb = unknown> {
+  tenantId: string;
+  spaceId: string;
+  actionInvocationId: string;
+  actionId: string;
+  /** Authenticated actor identity supplied by the host. Omitted only by legacy hosts and previews. */
+  actorId?: string;
+  actorType?: ActorType;
+  parameters: unknown;
+  db: TDb;
+  now?: Date;
+  mode?: PolicyEvaluationMode;
+  /**
+   * Optional runtime services bag, mirroring {@link FabricRuntimeServices} on
+   * `ActionContext`. Lets the host inject dependencies (HTTP clients, secret
+   * managers, external policy engines such as OPA, feature flags, etc.) that
+   * a code policy evaluator may need without resorting to module-level
+   * globals. The shape is opaque to the platform — adapters narrow it.
+   */
+  services?: FabricRuntimeServices;
+  /** Explicit code-policy catalog for this runtime; absence fails closed. */
+  resolveCodePolicy?: (policyId: PolicyId) => PolicyEvaluator | undefined;
+}
+interface PolicyFact {
+  name: string;
+  value: unknown;
+  label?: string;
+}
+type PolicyCorrectiveActionKind = "invoke_action" | "navigate" | "manual";
+interface PolicyCorrectiveActionBase {
+  kind: PolicyCorrectiveActionKind;
+  label: string;
+  description?: string;
+  requiresRole?: string[];
+  requiresConfirmation?: boolean;
+}
+interface PolicyInvokeActionCorrectiveAction extends PolicyCorrectiveActionBase {
+  kind: "invoke_action";
+  actionId: ActionId;
+  parameters?: Record<string, unknown>;
+}
+interface PolicyNavigateCorrectiveAction extends PolicyCorrectiveActionBase {
+  kind: "navigate";
+  route?: string;
+  target?: {
+    surface?: string;
+    tab?: string;
+    field?: string;
+  };
+}
+interface PolicyManualCorrectiveAction extends PolicyCorrectiveActionBase {
+  kind: "manual";
+}
+type PolicyCorrectiveAction = PolicyInvokeActionCorrectiveAction | PolicyNavigateCorrectiveAction | PolicyManualCorrectiveAction;
+interface PolicyGuidance {
+  summary?: string;
+  factsUsed: PolicyFact[];
+  correctiveActions: PolicyCorrectiveAction[];
+}
+interface PolicyGuidanceValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+declare function validatePolicyGuidance(guidance: unknown): PolicyGuidanceValidationResult;
+interface PolicyOutcome {
+  policyId: PolicyId;
+  policyVersion: number;
+  policyKind?: PolicyKind;
+  result: PolicyEvaluationResult;
+  reason?: string;
+  guidance?: PolicyGuidance;
+  metadata?: Record<string, unknown>;
+  dispatchEvidence?: PolicyDispatchEvidence;
+}
+interface PolicyEvaluator<TDb = unknown> {
+  policyId: PolicyId;
+  version: number;
+  kind?: Extract<PolicyKind, "code">;
+  previewSafe?: boolean;
+  evaluate: (ctx: PolicyContext<TDb>) => Promise<PolicyOutcome>;
+}
+type DataPolicySource = "parameters" | "context";
+type DataPolicyLiteral = string | number | boolean | null;
+type DataPolicyComparisonOperator = "exists" | "equals" | "notEquals" | "gt" | "gte" | "lt" | "lte";
+interface DataPolicySourceReference {
+  source: DataPolicySource;
+  path: string;
+}
+type DataPolicyCondition = {
+  conditionId: string;
+  type: "always";
+  result: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "parameter";
+  path: string;
+  operator: DataPolicyComparisonOperator;
+  value?: DataPolicyLiteral;
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "comparison";
+  left: DataPolicySourceReference;
+  operator: DataPolicyComparisonOperator;
+  value?: DataPolicyLiteral;
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "all" | "any";
+  conditions: DataPolicyCondition[];
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "not";
+  condition: DataPolicyCondition;
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+};
+interface DataPolicyDefinition {
+  conditions: DataPolicyCondition[];
+  defaultResult?: PolicyEvaluationResult;
+  reason?: string;
+}
+interface DataPolicyValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+interface PolicyFallbackDefinition {
+  codeEvaluatorPolicyId: PolicyId;
+  onResults?: PolicyEvaluationResult[];
+  triggers?: PolicyFallbackTrigger[];
+  reason?: string;
+}
+type PolicyFallbackTrigger = "data_result" | "missing_data_definition" | "invalid_data_definition";
+interface DataPolicyConditionResult {
+  conditionId: string;
+  passed: boolean;
+  result: PolicyEvaluationResult;
+  reason?: string;
+}
+/**
+ * Opaque, consumer-defined reference to the immutable policy authority or
+ * snapshot a runtime policy definition was resolved from. Platform records it
+ * in dispatch evidence and does not interpret it.
+ */
+interface PolicyAuthorityReference {
+  snapshotId: string;
+  contentHash?: string;
+}
+interface RuntimePolicyDefinition {
+  policyId: PolicyId;
+  policyVersion: number;
+  kind: PolicyKind;
+  /** Snapshot/authority this definition came from; copied into dispatch evidence. */
+  authority?: PolicyAuthorityReference;
+  dataDefinition?: DataPolicyDefinition;
+  codeEvaluatorPolicyId?: PolicyId;
+  fallback?: PolicyFallbackDefinition;
+}
+interface PolicyDispatchEvidence {
+  policyKind: PolicyKind;
+  policyId?: PolicyId;
+  policyVersion?: number;
+  /** Snapshot/authority the evaluated definition was resolved from, when supplied. */
+  authority?: PolicyAuthorityReference;
+  dispatchPath: Array<"data" | "code" | "fallback">;
+  data?: {
+    definitionVersion: number;
+    definitionStatus: "evaluated" | "missing" | "invalid";
+    conditionResults: DataPolicyConditionResult[];
+    validationErrors?: string[];
+  };
+  code?: {
+    requestedPolicyId?: PolicyId;
+    policyId: PolicyId;
+    version?: number;
+    registered: boolean;
+    skipped?: boolean;
+    skipReason?: string;
+  };
+  fallback?: {
+    used: boolean;
+    trigger: PolicyFallbackTrigger | "not_triggered";
+    reason: string;
+    fromResult?: PolicyEvaluationResult;
+    definitionVersion: number;
+    codeEvaluatorPolicyId: PolicyId;
+  };
+  /**
+   * Provenance for the engine that produced this decision when a code
+   * evaluator delegates to an external policy engine (OPA, Cedar, Cerbos,
+   * Topaz, etc.). Fabric's `policyId` / `policyVersion` remain canonical for
+   * audit; this block carries deployment provenance (decision path, bundle
+   * revision, decision ID, input hash). Adapters populate it; the platform
+   * keeps `metadata` open-ended so engine-specific typing can live in the
+   * adapter package.
+   */
+  engine?: {
+    name: string;
+    version?: string;
+    metadata?: Record<string, unknown>;
+  };
+}
+interface PolicyRegistry {
+  register(evaluator: PolicyEvaluator): void;
+  registerIfMissing(evaluator: PolicyEvaluator): void;
+  resolve(policyId: PolicyId): PolicyEvaluator | undefined;
+  ids(): PolicyId[];
+}
+declare function createPolicyRegistry(evaluators?: readonly PolicyEvaluator[]): PolicyRegistry;
+declare function evaluateRegisteredPolicies(policyIds: PolicyId[], ctx: PolicyContext): Promise<PolicyOutcome[]>;
+declare function evaluatePolicyDefinitions(policies: RuntimePolicyDefinition[], ctx: PolicyContext): Promise<PolicyOutcome[]>;
+declare function evaluatePolicyDefinition(policy: RuntimePolicyDefinition, ctx: PolicyContext): Promise<PolicyOutcome>;
+declare function validateDataPolicyDefinition(definition: DataPolicyDefinition): DataPolicyValidationResult;
+declare function aggregatePolicyOutcomes(outcomes: PolicyOutcome[]): PolicyOutcome | undefined;
+//#endregion
+export { RuntimePolicyDefinition as A, isRetryableExecutionError as B, PolicyId as C, PolicyNavigateCorrectiveAction as D, PolicyManualCorrectiveAction as E, evaluatePolicyDefinitions as F, isReconciliationRequiredError as H, evaluateRegisteredPolicies as I, validateDataPolicyDefinition as L, assertPolicyId as M, createPolicyRegistry as N, PolicyOutcome as O, evaluatePolicyDefinition as P, validatePolicyGuidance as R, PolicyGuidanceValidationResult as S, PolicyKind as T, ReconciliationRequiredError as V, PolicyEvaluator as _, DataPolicyLiteral as a, PolicyFallbackTrigger as b, DataPolicyValidationResult as c, PolicyCorrectiveAction as d, PolicyCorrectiveActionBase as f, PolicyEvaluationResult as g, PolicyEvaluationMode as h, DataPolicyDefinition as i, aggregatePolicyOutcomes as j, PolicyRegistry as k, PolicyAuthorityReference as l, PolicyDispatchEvidence as m, DataPolicyCondition as n, DataPolicySource as o, PolicyCorrectiveActionKind as p, DataPolicyConditionResult as r, DataPolicySourceReference as s, DataPolicyComparisonOperator as t, PolicyContext as u, PolicyFact as v, PolicyInvokeActionCorrectiveAction as w, PolicyGuidance as x, PolicyFallbackDefinition as y, RetryableExecutionError as z };

package/dist/index-DZ4mnNb7.d.cts

@@ -0,0 +1,78 @@
+//#region objects/index.d.ts
+type FabricObjectType = string;
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * Dependency-free JSON Schema profile accepted in portable module manifests.
+ * Unknown extension keywords must use an `x-` prefix. Runtime validators may
+ * support more vocabulary, but exported entity contracts stay in this profile.
+ */
+interface PortableJsonSchema {
+  $schema?: string;
+  $id?: string;
+  $ref?: string;
+  $defs?: Record<string, PortableJsonSchema>;
+  title?: string;
+  description?: string;
+  type?: "null" | "boolean" | "object" | "array" | "number" | "integer" | "string" | Array<"null" | "boolean" | "object" | "array" | "number" | "integer" | "string">;
+  enum?: JsonValue[];
+  const?: JsonValue;
+  properties?: Record<string, PortableJsonSchema>;
+  required?: string[];
+  additionalProperties?: boolean | PortableJsonSchema;
+  items?: PortableJsonSchema | PortableJsonSchema[];
+  prefixItems?: PortableJsonSchema[];
+  propertyNames?: PortableJsonSchema;
+  patternProperties?: Record<string, PortableJsonSchema>;
+  dependentRequired?: Record<string, string[]>;
+  allOf?: PortableJsonSchema[];
+  anyOf?: PortableJsonSchema[];
+  oneOf?: PortableJsonSchema[];
+  not?: PortableJsonSchema;
+  if?: PortableJsonSchema;
+  then?: PortableJsonSchema;
+  else?: PortableJsonSchema;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  default?: JsonValue;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  deprecated?: boolean;
+  contentEncoding?: string;
+  contentMediaType?: string;
+  examples?: JsonValue[];
+  $comment?: string;
+  [key: `x-${string}`]: JsonValue | undefined;
+}
+declare function assertPortableJsonSchema(schema: unknown, path?: string): asserts schema is PortableJsonSchema;
+interface JsonSchemaValidationIssue {
+  path: Array<string | number>;
+  message: string;
+}
+/**
+ * Validate JSON data against the dependency-free JSON Schema profile used by
+ * portable contracts. This intentionally returns issues instead of throwing so
+ * hosts can expose a stable, typed validation failure without leaking values.
+ */
+declare function validatePortableJson(schema: PortableJsonSchema, value: unknown): JsonSchemaValidationIssue[];
+declare function assertObjectType(type: string): asserts type is FabricObjectType;
+interface ObjectTypeRegistry {
+  register(type: string): void;
+  has(type: string): boolean;
+  list(): string[];
+}
+declare function createObjectTypeRegistry(initialTypes?: readonly string[]): ObjectTypeRegistry;
+//#endregion
+export { ObjectTypeRegistry as a, assertPortableJsonSchema as c, JsonValue as i, createObjectTypeRegistry as l, JsonPrimitive as n, PortableJsonSchema as o, JsonSchemaValidationIssue as r, assertObjectType as s, FabricObjectType as t, validatePortableJson as u };

package/dist/index-DZ4mnNb7.d.ts

@@ -0,0 +1,78 @@
+//#region objects/index.d.ts
+type FabricObjectType = string;
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * Dependency-free JSON Schema profile accepted in portable module manifests.
+ * Unknown extension keywords must use an `x-` prefix. Runtime validators may
+ * support more vocabulary, but exported entity contracts stay in this profile.
+ */
+interface PortableJsonSchema {
+  $schema?: string;
+  $id?: string;
+  $ref?: string;
+  $defs?: Record<string, PortableJsonSchema>;
+  title?: string;
+  description?: string;
+  type?: "null" | "boolean" | "object" | "array" | "number" | "integer" | "string" | Array<"null" | "boolean" | "object" | "array" | "number" | "integer" | "string">;
+  enum?: JsonValue[];
+  const?: JsonValue;
+  properties?: Record<string, PortableJsonSchema>;
+  required?: string[];
+  additionalProperties?: boolean | PortableJsonSchema;
+  items?: PortableJsonSchema | PortableJsonSchema[];
+  prefixItems?: PortableJsonSchema[];
+  propertyNames?: PortableJsonSchema;
+  patternProperties?: Record<string, PortableJsonSchema>;
+  dependentRequired?: Record<string, string[]>;
+  allOf?: PortableJsonSchema[];
+  anyOf?: PortableJsonSchema[];
+  oneOf?: PortableJsonSchema[];
+  not?: PortableJsonSchema;
+  if?: PortableJsonSchema;
+  then?: PortableJsonSchema;
+  else?: PortableJsonSchema;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  default?: JsonValue;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  deprecated?: boolean;
+  contentEncoding?: string;
+  contentMediaType?: string;
+  examples?: JsonValue[];
+  $comment?: string;
+  [key: `x-${string}`]: JsonValue | undefined;
+}
+declare function assertPortableJsonSchema(schema: unknown, path?: string): asserts schema is PortableJsonSchema;
+interface JsonSchemaValidationIssue {
+  path: Array<string | number>;
+  message: string;
+}
+/**
+ * Validate JSON data against the dependency-free JSON Schema profile used by
+ * portable contracts. This intentionally returns issues instead of throwing so
+ * hosts can expose a stable, typed validation failure without leaking values.
+ */
+declare function validatePortableJson(schema: PortableJsonSchema, value: unknown): JsonSchemaValidationIssue[];
+declare function assertObjectType(type: string): asserts type is FabricObjectType;
+interface ObjectTypeRegistry {
+  register(type: string): void;
+  has(type: string): boolean;
+  list(): string[];
+}
+declare function createObjectTypeRegistry(initialTypes?: readonly string[]): ObjectTypeRegistry;
+//#endregion
+export { ObjectTypeRegistry as a, assertPortableJsonSchema as c, JsonValue as i, createObjectTypeRegistry as l, JsonPrimitive as n, PortableJsonSchema as o, JsonSchemaValidationIssue as r, assertObjectType as s, FabricObjectType as t, validatePortableJson as u };

package/dist/index-IqcDvl69.d.ts

@@ -0,0 +1,124 @@
+import { t as SurfaceDeclaration } from "./index-CIl1rYRv.js";
+import { o as PortableJsonSchema } from "./index-DZ4mnNb7.js";
+//#region projections/index.d.ts
+interface ReplayableAssetEvent<Payload = unknown> {
+  id: string;
+  tenantId: string;
+  spaceId: string;
+  eventType: string;
+  eventSchemaVersion?: number;
+  subjectType: string;
+  subjectId: string;
+  payload: Payload;
+  /**
+   * Monotonic ordering cursor for the tenant/space event ledger. It is not
+   * contiguous after a view filters event types or narrows to one subject.
+   */
+  sequence: number;
+  /** Optional contiguous sequence local to this subject. */
+  subjectSequence?: number;
+  occurredAt: Date | string;
+  recordedAt: Date | string;
+  actionInvocationId: string;
+  correlationId: string;
+}
+interface ViewEventConsumption {
+  eventType: string;
+  schemaVersions: number[];
+}
+interface ViewContract<State = unknown, Event extends ReplayableAssetEvent = ReplayableAssetEvent> extends SurfaceDeclaration {
+  /** Stable module-qualified logical identity, for example `orders/summary`. */
+  name: `${string}/${string}`;
+  version: string;
+  shape: PortableJsonSchema;
+  /** Optional JSON Schema for query parameters. Parameterized variants get isolated snapshots. */
+  parameterSchema?: PortableJsonSchema;
+  consumes: ViewEventConsumption[];
+  scope: "tenant-space";
+  snapshotVersion: number;
+  compatibleSnapshotVersions?: number[];
+  usage?: ViewUsageMetadata;
+  /** Required to transform any older compatible snapshot into the current state shape. */
+  upgradeSnapshot?: (data: unknown, fromVersion: number) => State | Promise<State>;
+  initialState: State;
+  applyEvent: (state: State, event: Event) => State | Promise<State>;
+}
+interface ViewUsageMetadata {
+  semanticRole?: string;
+  collection?: {
+    pagination: "cursor" | "offset" | "none";
+    filterSchema?: PortableJsonSchema;
+    sortFields?: string[];
+  };
+  freshness?: {
+    maximumAgeSeconds?: number;
+    offlineUsable?: boolean;
+  };
+  classification?: "public" | "internal" | "confidential" | "restricted";
+}
+declare function viewContractKey(view: Pick<ViewContract, "name" | "version">): string;
+interface ViewRegistry {
+  register(view: ViewContract): void;
+  registerIfMissing(view: ViewContract): void;
+  resolve(name: string, version: string): ViewContract | undefined;
+  keys(): string[];
+}
+declare function createViewRegistry(views?: readonly ViewContract[]): ViewRegistry;
+interface ReplayViewOptions<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+  view: ViewContract<State, Event>;
+  events: Iterable<Event> | AsyncIterable<Event>;
+  scope: ReplayScope;
+  snapshot?: (ReplaySnapshot<State> & {
+    snapshotVersion: number;
+  }) | null;
+  /**
+   * Set when the event source already applied the snapshot cursor and returns
+   * only later events. The snapshot still seeds state, but replay must not try
+   * to find its cursor in the supplied incremental stream.
+   */
+  eventsStartAfterSnapshot?: boolean;
+}
+declare function replayView<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent>({ view, events, scope, snapshot, eventsStartAfterSnapshot }: ReplayViewOptions<State, Event>): Promise<ReplayEventsResult<State, Event>>;
+interface ReplayScope {
+  tenantId: string;
+  spaceId: string;
+  subjectType?: string;
+  subjectId?: string;
+}
+interface ReplaySnapshot<State = unknown> {
+  snapshotData: State;
+  eventCursor?: string | null;
+  eventSequence?: number | null;
+  /** Per-subject high-water marks. Values prefer subjectSequence when supplied. */
+  subjectSequences?: Record<string, number>;
+}
+type ReplayWarningCode = "cursor_not_found" | "duplicate_event" | "missing_sequence" | "subject_scope_incomplete" | "unsupported_event_version";
+interface ReplayWarning {
+  code: ReplayWarningCode;
+  message: string;
+  eventId?: string;
+  subjectType?: string;
+  subjectId?: string;
+  expectedSequence?: number;
+  actualSequence?: number;
+}
+interface ReplayEventsOptions<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+  events: Iterable<Event> | AsyncIterable<Event>;
+  scope: ReplayScope;
+  initialState: State;
+  snapshot?: ReplaySnapshot<State> | null;
+  applyEvent: (state: State, event: Event) => State | Promise<State>;
+  /** The supplied stream begins after the snapshot checkpoint. */
+  eventsStartAfterSnapshot?: boolean;
+}
+interface ReplayEventsResult<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+  state: State;
+  appliedEvents: Event[];
+  warnings: ReplayWarning[];
+  eventCursor: string | null;
+  eventSequence: number;
+  subjectSequences: Record<string, number>;
+}
+declare function replayEvents<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent>({ events, scope, initialState, snapshot, applyEvent, eventsStartAfterSnapshot }: ReplayEventsOptions<State, Event>): Promise<ReplayEventsResult<State, Event>>;
+//#endregion
+export { ReplayViewOptions as a, ReplayableAssetEvent as c, ViewRegistry as d, ViewUsageMetadata as f, viewContractKey as g, replayView as h, ReplaySnapshot as i, ViewContract as l, replayEvents as m, ReplayEventsResult as n, ReplayWarning as o, createViewRegistry as p, ReplayScope as r, ReplayWarningCode as s, ReplayEventsOptions as t, ViewEventConsumption as u };

package/dist/index-fmUiRBXu.d.cts

@@ -0,0 +1,57 @@
+//#region state-machines/engine.d.ts
+interface StateMachineDefinition {
+  entityType: string;
+  states: Record<string, StateDefinition>;
+  transitions: Array<{
+    from: string;
+    to: string;
+    causedByAction: string;
+    guard?: (ctx: TransitionContext) => boolean | Promise<boolean>;
+  }>;
+}
+type StateMachineDatabaseClient = unknown;
+interface TransitionContext<TDb = StateMachineDatabaseClient> {
+  entity: Record<string, unknown>;
+  actionInvocationId: string;
+  actorId: string;
+  parameters: unknown;
+  db: TDb;
+}
+interface StateMachineRegistry {
+  register(definition: StateMachineDefinition): void;
+  registerIfMissing(definition: StateMachineDefinition): void;
+  resolve(entityType: string): StateMachineDefinition | undefined;
+  validateTransition(entityType: string, from: string, to: string, actionId: string): {
+    valid: boolean;
+    error?: string;
+  };
+  allowedTransitions(entityType: string, from: string): Array<{
+    to: string;
+    causedByAction: string;
+  }>;
+  stateClass(entityType: string, state: string): StateClass | undefined;
+}
+declare function validateStateMachineTransition(sm: StateMachineDefinition | undefined, entityType: string, from: string, to: string, actionId: string): {
+  valid: boolean;
+  error?: string;
+};
+/**
+ * Validates a transition and evaluates its declared guard against trusted Host
+ * context. Callers must construct `context.entity` from authoritative state,
+ * never from action parameters.
+ */
+declare function evaluateStateMachineTransition<TDb = StateMachineDatabaseClient>(sm: StateMachineDefinition | undefined, entityType: string, from: string, to: string, actionId: string, context: TransitionContext<TDb>): Promise<{
+  valid: boolean;
+  error?: string;
+}>;
+declare function createStateMachineRegistry(definitions?: readonly StateMachineDefinition[]): StateMachineRegistry;
+//#endregion
+//#region state-machines/index.d.ts
+type StateClass = "initial" | "active" | "action_required" | "waiting" | "terminal" | "exception";
+interface StateDefinition {
+  id: string;
+  label: string;
+  stateClass: StateClass;
+}
+//#endregion
+export { StateMachineRegistry as a, evaluateStateMachineTransition as c, StateMachineDefinition as i, validateStateMachineTransition as l, StateDefinition as n, TransitionContext as o, StateMachineDatabaseClient as r, createStateMachineRegistry as s, StateClass as t };

package/dist/index-fmUiRBXu.d.ts

@@ -0,0 +1,57 @@
+//#region state-machines/engine.d.ts
+interface StateMachineDefinition {
+  entityType: string;
+  states: Record<string, StateDefinition>;
+  transitions: Array<{
+    from: string;
+    to: string;
+    causedByAction: string;
+    guard?: (ctx: TransitionContext) => boolean | Promise<boolean>;
+  }>;
+}
+type StateMachineDatabaseClient = unknown;
+interface TransitionContext<TDb = StateMachineDatabaseClient> {
+  entity: Record<string, unknown>;
+  actionInvocationId: string;
+  actorId: string;
+  parameters: unknown;
+  db: TDb;
+}
+interface StateMachineRegistry {
+  register(definition: StateMachineDefinition): void;
+  registerIfMissing(definition: StateMachineDefinition): void;
+  resolve(entityType: string): StateMachineDefinition | undefined;
+  validateTransition(entityType: string, from: string, to: string, actionId: string): {
+    valid: boolean;
+    error?: string;
+  };
+  allowedTransitions(entityType: string, from: string): Array<{
+    to: string;
+    causedByAction: string;
+  }>;
+  stateClass(entityType: string, state: string): StateClass | undefined;
+}
+declare function validateStateMachineTransition(sm: StateMachineDefinition | undefined, entityType: string, from: string, to: string, actionId: string): {
+  valid: boolean;
+  error?: string;
+};
+/**
+ * Validates a transition and evaluates its declared guard against trusted Host
+ * context. Callers must construct `context.entity` from authoritative state,
+ * never from action parameters.
+ */
+declare function evaluateStateMachineTransition<TDb = StateMachineDatabaseClient>(sm: StateMachineDefinition | undefined, entityType: string, from: string, to: string, actionId: string, context: TransitionContext<TDb>): Promise<{
+  valid: boolean;
+  error?: string;
+}>;
+declare function createStateMachineRegistry(definitions?: readonly StateMachineDefinition[]): StateMachineRegistry;
+//#endregion
+//#region state-machines/index.d.ts
+type StateClass = "initial" | "active" | "action_required" | "waiting" | "terminal" | "exception";
+interface StateDefinition {
+  id: string;
+  label: string;
+  stateClass: StateClass;
+}
+//#endregion
+export { StateMachineRegistry as a, evaluateStateMachineTransition as c, StateMachineDefinition as i, validateStateMachineTransition as l, StateDefinition as n, TransitionContext as o, StateMachineDatabaseClient as r, createStateMachineRegistry as s, StateClass as t };