@fabricorg/platform 0.1.2 → 0.2.0

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/index.d.cts

@@ -0,0 +1,13 @@
+export { ACTOR_TYPES, ActionContext, ActionDefinition, ActionHandler, ActionId, ActionResult, ActionStateMachineBinding, ActionStatus, ActorType, AdapterStep, AdapterStepRetryPolicy, FabricRuntimeServices, SagaChildActionInput, SagaCompletion, SagaCompletionEvent, SagaContext, SagaImplementation, SagaRunChild, SchemaParseIssue, SchemaParseResult, SchemaValidator, assertActionId, assertActorType, getRegisteredActionIds, isActorType, isRegisteredActionId, registerAction, registerActionIfMissing, resolveAction, resolveRegisteredAction } from './actions/index.cjs';
+export { AdapterAttempt, AdapterCircuitBreakerConfig, AdapterExecutionContext, AdapterExecutionResult, AdapterExecutor, AdapterImplementation, AdapterRegistry, AdapterRetryPolicy, ExecuteWithRetryOptions, MissingAdapterRegistrationError, ResolvedAdapterRetryPolicy, executeWithAdapterRetry, getRetryDelayMs, resolveAdapterRetryPolicy } from './adapters/index.cjs';
+export { AssetEventActorType, AssetEventEnvelope, AssetEventSubjectType, AssetEventType, EventTypeRegistry, createEventTypeRegistry, getRegisteredEventTypes, getRegisteredSubjectTypes, isValidEventType, isValidSubjectType, registerEventType, registerSubjectType } from './events/index.cjs';
+export { FABRIC_ID_PREFIXES, FabricIdPrefix, createFabricId, isFabricId, parseFabricId } from './ids/index.cjs';
+export { EventTypeRegistration, EventTypeRegistrationInput, FabricModule, IdPrefixRegistration, ModuleDependency, ModuleDependencyInput, ModuleDisplayRendererRegistration, ModuleRegistry, ObjectTypeRegistration, ObjectTypeRegistrationInput, PolicyRegistration, StateMachineRegistration, createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace } from './modules/index.cjs';
+export { FabricObjectType, assertObjectType, getRegisteredObjectTypes, isValidObjectType, registerObjectType } from './objects/index.cjs';
+export { DataPolicyComparisonOperator, DataPolicyCondition, DataPolicyConditionResult, DataPolicyDefinition, DataPolicyLiteral, DataPolicySource, DataPolicySourceReference, DataPolicyValidationResult, PolicyContext, PolicyDispatchEvidence, PolicyEvaluationMode, PolicyEvaluationResult, PolicyEvaluator, PolicyFallbackDefinition, PolicyFallbackTrigger, PolicyId, PolicyKind, PolicyOutcome, RuntimePolicyDefinition, aggregatePolicyOutcomes, assertPolicyId, evaluatePolicyDefinition, evaluatePolicyDefinitions, evaluateRegisteredPolicies, getRegisteredPolicyIds, registerPolicy, registerPolicyIfMissing, resolvePolicy, validateDataPolicyDefinition } from './policies/index.cjs';
+export { StateClass, StateDefinition, StateMachineDatabaseClient, StateMachineDefinition, TransitionContext, getAllowedTransitions, getEntityStateClass, registerStateMachine, registerStateMachineIfMissing, resolveStateMachine, validateTransition } from './state-machines/index.cjs';
+export { ReplayEventsOptions, ReplayEventsResult, ReplayScope, ReplaySnapshot, ReplayWarning, ReplayWarningCode, ReplayableAssetEvent, replayEvents } from './projections/index.cjs';
+export { CachedDisplayDescriptor, DisplayContext, DisplayDatabaseClient, DisplayDescriptor, DisplayRenderer, DisplayRendererRegistration, denormalizeDisplaySnapshot, registerDisplayRenderer, renderEventDisplay, resolveDisplayRenderer } from './displays/index.cjs';
+export { AnalyticsDataContract, AnalyticsDataContractSource, AnalyticsEligibilityDecision, AnonymizationContext, AnonymizationFieldMetadata, AnonymizationMetadata, AnonymizationResult, DataClassificationRule, PLATFORM_PRIVACY_POLICY_VERSION, PlatformDataClass, RedactionMethod, RedactionRule, RetentionRule } from './privacy/index.cjs';
+export { EvidenceGenerationContext, EvidencePacketEnvelope, EvidencePacketReference, EvidencePacketStatus, EvidencePacketSubject, EvidenceRenderer } from './evidence/index.cjs';
+export { FakeActionContextOptions, createDeterministicIdFactory, createFakeActionContext, createInMemoryAdapterRegistry } from './testing/index.cjs';

package/dist/modules/index.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var chunkLYX73U3P_cjs = require('../chunk-LYX73U3P.cjs');
+require('../chunk-QETQGAXJ.cjs');
+require('../chunk-SDXDHVTV.cjs');
+require('../chunk-GB2PSZ33.cjs');
+require('../chunk-KQEBNUZI.cjs');
+require('../chunk-7KJHGAZY.cjs');
+require('../chunk-JAXDEK5Z.cjs');
+
+
+
+Object.defineProperty(exports, "createModuleRegistry", {
+  enumerable: true,
+  get: function () { return chunkLYX73U3P_cjs.createModuleRegistry; }
+});
+Object.defineProperty(exports, "getEventTypeName", {
+  enumerable: true,
+  get: function () { return chunkLYX73U3P_cjs.getEventTypeName; }
+});
+Object.defineProperty(exports, "getModuleDependencyNamespace", {
+  enumerable: true,
+  get: function () { return chunkLYX73U3P_cjs.getModuleDependencyNamespace; }
+});
+Object.defineProperty(exports, "getObjectTypeName", {
+  enumerable: true,
+  get: function () { return chunkLYX73U3P_cjs.getObjectTypeName; }
+});
+Object.defineProperty(exports, "registerFabricModule", {
+  enumerable: true,
+  get: function () { return chunkLYX73U3P_cjs.registerFabricModule; }
+});
+Object.defineProperty(exports, "registerFabricModules", {
+  enumerable: true,
+  get: function () { return chunkLYX73U3P_cjs.registerFabricModules; }
+});
+Object.defineProperty(exports, "validateModuleNamespace", {
+  enumerable: true,
+  get: function () { return chunkLYX73U3P_cjs.validateModuleNamespace; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/modules/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/modules/index.d.cts

@@ -0,0 +1,73 @@
+import { ActionDefinition } from '../actions/index.cjs';
+
+interface ModuleDependency {
+    namespace: string;
+    version?: string;
+    optional?: boolean;
+}
+type ModuleDependencyInput = string | ModuleDependency;
+interface IdPrefixRegistration {
+    prefix: string;
+    name: string;
+    module: string;
+}
+interface EventTypeRegistration {
+    eventType: string;
+    schemaVersion: number;
+    description?: string;
+}
+type EventTypeRegistrationInput = string | EventTypeRegistration;
+interface ObjectTypeRegistration {
+    type: string;
+    displayName?: string;
+    idPrefix?: string;
+    isCoreModuleType?: boolean;
+}
+type ObjectTypeRegistrationInput = string | ObjectTypeRegistration;
+interface ModuleDisplayRendererRegistration {
+    eventType: string;
+    renderer: (payload: unknown, ctx?: any) => unknown;
+}
+interface PolicyRegistration {
+    id: string;
+    version?: string;
+    description?: string;
+}
+interface StateMachineRegistration {
+    entityType: string;
+    states: string[];
+}
+interface FabricModule<TDb = unknown> {
+    namespace: string;
+    version?: string;
+    displayName?: string;
+    description?: string;
+    dependencies?: ModuleDependencyInput[];
+    objectTypes?: ObjectTypeRegistrationInput[];
+    subjectTypes?: string[];
+    idPrefixes?: IdPrefixRegistration[];
+    eventTypes?: EventTypeRegistrationInput[];
+    actions?: ActionDefinition<TDb>[];
+    policies?: unknown[];
+    stateMachines?: unknown[];
+    displayRenderers?: ModuleDisplayRendererRegistration[];
+    adapterDefinitions?: unknown[];
+    permissions?: unknown[];
+    roles?: unknown[];
+    redactionRules?: unknown[];
+    dataClassifications?: unknown[];
+    retentionRules?: unknown[];
+    evidenceRenderers?: unknown[];
+}
+interface ModuleRegistry<TDb = unknown> {
+    modules: ReadonlyMap<string, FabricModule<TDb>>;
+}
+declare function getModuleDependencyNamespace(dependency: ModuleDependencyInput): string;
+declare function getObjectTypeName(objectType: ObjectTypeRegistrationInput): string;
+declare function getEventTypeName(eventType: EventTypeRegistrationInput): string;
+declare function validateModuleNamespace(namespace: string): void;
+declare function createModuleRegistry<TDb = unknown>(modules?: FabricModule<TDb>[]): ModuleRegistry<TDb>;
+declare function registerFabricModule(module: FabricModule<any>): void;
+declare function registerFabricModules(modules: FabricModule<any>[]): FabricModule<any>[];
+
+export { type EventTypeRegistration, type EventTypeRegistrationInput, type FabricModule, type IdPrefixRegistration, type ModuleDependency, type ModuleDependencyInput, type ModuleDisplayRendererRegistration, type ModuleRegistry, type ObjectTypeRegistration, type ObjectTypeRegistrationInput, type PolicyRegistration, type StateMachineRegistration, createModuleRegistry, getEventTypeName, getModuleDependencyNamespace, getObjectTypeName, registerFabricModule, registerFabricModules, validateModuleNamespace };

package/dist/objects/index.cjs

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

package/dist/objects/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/objects/index.d.cts

@@ -0,0 +1,7 @@
+type FabricObjectType = string;
+declare function assertObjectType(type: string): asserts type is FabricObjectType;
+declare function registerObjectType(type: string): void;
+declare function isValidObjectType(type: string): boolean;
+declare function getRegisteredObjectTypes(): string[];
+
+export { type FabricObjectType, assertObjectType, getRegisteredObjectTypes, isValidObjectType, registerObjectType };

package/dist/policies/index.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var chunkSDXDHVTV_cjs = require('../chunk-SDXDHVTV.cjs');
+
+
+
+Object.defineProperty(exports, "aggregatePolicyOutcomes", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.aggregatePolicyOutcomes; }
+});
+Object.defineProperty(exports, "assertPolicyId", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.assertPolicyId; }
+});
+Object.defineProperty(exports, "evaluatePolicyDefinition", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.evaluatePolicyDefinition; }
+});
+Object.defineProperty(exports, "evaluatePolicyDefinitions", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.evaluatePolicyDefinitions; }
+});
+Object.defineProperty(exports, "evaluateRegisteredPolicies", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.evaluateRegisteredPolicies; }
+});
+Object.defineProperty(exports, "getRegisteredPolicyIds", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.getRegisteredPolicyIds; }
+});
+Object.defineProperty(exports, "registerPolicy", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.registerPolicy; }
+});
+Object.defineProperty(exports, "registerPolicyIfMissing", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.registerPolicyIfMissing; }
+});
+Object.defineProperty(exports, "resolvePolicy", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.resolvePolicy; }
+});
+Object.defineProperty(exports, "validateDataPolicyDefinition", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.validateDataPolicyDefinition; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/policies/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/policies/index.d.cts

@@ -0,0 +1,143 @@
+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;
+    parameters: unknown;
+    db: TDb;
+    now?: Date;
+    mode?: PolicyEvaluationMode;
+}
+interface PolicyOutcome {
+    policyId: PolicyId;
+    policyVersion: number;
+    policyKind?: PolicyKind;
+    result: PolicyEvaluationResult;
+    reason?: string;
+    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;
+}
+interface RuntimePolicyDefinition {
+    policyId: PolicyId;
+    policyVersion: number;
+    kind: PolicyKind;
+    dataDefinition?: DataPolicyDefinition;
+    codeEvaluatorPolicyId?: PolicyId;
+    fallback?: PolicyFallbackDefinition;
+}
+interface PolicyDispatchEvidence {
+    policyKind: PolicyKind;
+    policyId?: PolicyId;
+    policyVersion?: number;
+    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;
+    };
+    fallback?: {
+        used: boolean;
+        trigger: PolicyFallbackTrigger | "not_triggered";
+        reason: string;
+        fromResult?: PolicyEvaluationResult;
+        definitionVersion: number;
+        codeEvaluatorPolicyId: PolicyId;
+    };
+}
+declare function registerPolicy(evaluator: PolicyEvaluator): void;
+declare function registerPolicyIfMissing(evaluator: PolicyEvaluator): void;
+declare function resolvePolicy(policyId: PolicyId): PolicyEvaluator | undefined;
+declare function getRegisteredPolicyIds(): PolicyId[];
+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;
+
+export { type DataPolicyComparisonOperator, type DataPolicyCondition, type DataPolicyConditionResult, type DataPolicyDefinition, type DataPolicyLiteral, type DataPolicySource, type DataPolicySourceReference, type DataPolicyValidationResult, type PolicyContext, type PolicyDispatchEvidence, type PolicyEvaluationMode, type PolicyEvaluationResult, type PolicyEvaluator, type PolicyFallbackDefinition, type PolicyFallbackTrigger, type PolicyId, type PolicyKind, type PolicyOutcome, type RuntimePolicyDefinition, aggregatePolicyOutcomes, assertPolicyId, evaluatePolicyDefinition, evaluatePolicyDefinitions, evaluateRegisteredPolicies, getRegisteredPolicyIds, registerPolicy, registerPolicyIfMissing, resolvePolicy, validateDataPolicyDefinition };

package/dist/privacy/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkLHCSVEFT_cjs = require('../chunk-LHCSVEFT.cjs');
+
+
+
+Object.defineProperty(exports, "PLATFORM_PRIVACY_POLICY_VERSION", {
+  enumerable: true,
+  get: function () { return chunkLHCSVEFT_cjs.PLATFORM_PRIVACY_POLICY_VERSION; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/privacy/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/privacy/index.d.cts

@@ -0,0 +1,77 @@
+declare const PLATFORM_PRIVACY_POLICY_VERSION = "fabric-platform-privacy-v1";
+type RedactionMethod = "nullify" | "mask" | "hash" | "tokenize" | "generalize" | "drop";
+type PlatformDataClass = "asset_event" | "read_model" | "raw_payload" | "evidence_packet" | "action_evidence" | "access_event";
+interface RedactionRule {
+    fieldPath: string;
+    method: RedactionMethod;
+    reason: string;
+    dataClass?: PlatformDataClass;
+}
+interface DataClassificationRule {
+    fieldPath: string;
+    classification: string;
+    containsDirectIdentifier?: boolean;
+    containsSensitiveData?: boolean;
+}
+interface AnonymizationContext {
+    tenantId: string;
+    spaceId?: string | null;
+    jobId: string;
+    reason: string;
+    redactedAt?: Date;
+    policyVersion?: string;
+}
+interface AnonymizationFieldMetadata {
+    fieldPath: string;
+    method: RedactionMethod;
+    policyVersion: string;
+    jobId: string;
+    redactedAt: string;
+    reason: string;
+    dataClass: PlatformDataClass;
+    beforeChecksum: string;
+}
+interface AnonymizationMetadata {
+    redactionState: "anonymized";
+    policyVersion: string;
+    jobId: string;
+    redactedAt: string;
+    reason: string;
+    dataClass: PlatformDataClass;
+    redactedFields: AnonymizationFieldMetadata[];
+    preservedSemantics: string[];
+}
+interface AnonymizationResult<TValue> {
+    value: TValue;
+    metadata: AnonymizationMetadata;
+}
+interface AnalyticsDataContractSource {
+    name: string;
+    privacyClass: "raw" | "operational_pii" | "tenant_scoped_tokenized" | "anonymized" | "aggregated" | "differentially_minimized";
+    containsDirectIdentifiers?: boolean;
+    containsGloballyStablePersonTokens?: boolean;
+    anonymizationPolicyVersion?: string;
+    minimumGroupSize?: number;
+}
+interface AnalyticsDataContract {
+    contractId: string;
+    status: "draft" | "accepted" | "deprecated";
+    crossTenant: boolean;
+    acceptedBy?: string;
+    acceptedAt?: string;
+    adrReference?: string;
+    sources: AnalyticsDataContractSource[];
+}
+interface AnalyticsEligibilityDecision {
+    eligible: boolean;
+    policyVersion: string;
+    reasons: string[];
+}
+interface RetentionRule {
+    dataClass: PlatformDataClass;
+    retainForDays: number;
+    afterRetention: "delete" | "anonymize" | "archive";
+    legalHoldExempt?: boolean;
+}
+
+export { type AnalyticsDataContract, type AnalyticsDataContractSource, type AnalyticsEligibilityDecision, type AnonymizationContext, type AnonymizationFieldMetadata, type AnonymizationMetadata, type AnonymizationResult, type DataClassificationRule, PLATFORM_PRIVACY_POLICY_VERSION, type PlatformDataClass, type RedactionMethod, type RedactionRule, type RetentionRule };

package/dist/projections/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkQ3WYIWCN_cjs = require('../chunk-Q3WYIWCN.cjs');
+
+
+
+Object.defineProperty(exports, "replayEvents", {
+  enumerable: true,
+  get: function () { return chunkQ3WYIWCN_cjs.replayEvents; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/projections/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/projections/index.d.cts

@@ -0,0 +1,52 @@
+interface ReplayableAssetEvent<Payload = unknown> {
+    id: string;
+    tenantId: string;
+    spaceId: string;
+    eventType: string;
+    subjectType: string;
+    subjectId: string;
+    payload: Payload;
+    sequence: number;
+    occurredAt: Date | string;
+    recordedAt: Date | string;
+    actionInvocationId: string;
+    correlationId: string;
+}
+interface ReplayScope {
+    tenantId: string;
+    spaceId: string;
+    subjectType?: string;
+    subjectId?: string;
+}
+interface ReplaySnapshot<State = unknown> {
+    snapshotData: State;
+    eventCursor?: string | null;
+    eventSequence?: number | null;
+}
+type ReplayWarningCode = "cursor_not_found" | "duplicate_event" | "missing_sequence" | "subject_scope_incomplete";
+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>;
+}
+interface ReplayEventsResult<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent> {
+    state: State;
+    appliedEvents: Event[];
+    warnings: ReplayWarning[];
+    eventCursor: string | null;
+    eventSequence: number;
+}
+declare function replayEvents<State, Event extends ReplayableAssetEvent = ReplayableAssetEvent>({ events, scope, initialState, snapshot, applyEvent, }: ReplayEventsOptions<State, Event>): Promise<ReplayEventsResult<State, Event>>;
+
+export { type ReplayEventsOptions, type ReplayEventsResult, type ReplayScope, type ReplaySnapshot, type ReplayWarning, type ReplayWarningCode, type ReplayableAssetEvent, replayEvents };

package/dist/state-machines/index.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var chunkGB2PSZ33_cjs = require('../chunk-GB2PSZ33.cjs');
+
+
+
+Object.defineProperty(exports, "getAllowedTransitions", {
+  enumerable: true,
+  get: function () { return chunkGB2PSZ33_cjs.getAllowedTransitions; }
+});
+Object.defineProperty(exports, "getEntityStateClass", {
+  enumerable: true,
+  get: function () { return chunkGB2PSZ33_cjs.getEntityStateClass; }
+});
+Object.defineProperty(exports, "registerStateMachine", {
+  enumerable: true,
+  get: function () { return chunkGB2PSZ33_cjs.registerStateMachine; }
+});
+Object.defineProperty(exports, "registerStateMachineIfMissing", {
+  enumerable: true,
+  get: function () { return chunkGB2PSZ33_cjs.registerStateMachineIfMissing; }
+});
+Object.defineProperty(exports, "resolveStateMachine", {
+  enumerable: true,
+  get: function () { return chunkGB2PSZ33_cjs.resolveStateMachine; }
+});
+Object.defineProperty(exports, "validateTransition", {
+  enumerable: true,
+  get: function () { return chunkGB2PSZ33_cjs.validateTransition; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/state-machines/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/state-machines/index.d.cts

@@ -0,0 +1,60 @@
+interface StateMachineDefinition {
+    entityType: string;
+    states: Record<string, StateDefinition>;
+    transitions: Array<{
+        from: string;
+        to: string;
+        causedByAction: string;
+        guard?: (ctx: TransitionContext) => boolean | Promise<boolean>;
+    }>;
+}
+type StateMachineDatabaseClient = any;
+interface TransitionContext<TDb = StateMachineDatabaseClient> {
+    entity: Record<string, unknown>;
+    actionInvocationId: string;
+    actorId: string;
+    parameters: unknown;
+    db: TDb;
+}
+/**
+ * Register a state-machine definition for an entity type.
+ * Throws if a definition for this entity type is already registered.
+ */
+declare function registerStateMachine(def: StateMachineDefinition): void;
+/**
+ * Register a state-machine definition only if one for this entity type
+ * is not already registered. Idempotent — safe to call multiple times.
+ */
+declare function registerStateMachineIfMissing(def: StateMachineDefinition): void;
+/**
+ * Resolve a previously registered state-machine definition by entity type.
+ */
+declare function resolveStateMachine(entityType: string): StateMachineDefinition | undefined;
+/**
+ * Validate whether a transition is allowed for the given entity type,
+ * from state, to state, and action ID.
+ */
+declare function validateTransition(entityType: string, from: string, to: string, actionId: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Get all allowed transitions from a given state for an entity type.
+ */
+declare function getAllowedTransitions(entityType: string, from: string): Array<{
+    to: string;
+    causedByAction: string;
+}>;
+/**
+ * Get the StateClass of a given state for an entity type.
+ */
+declare function getEntityStateClass(entityType: string, state: string): StateClass | undefined;
+
+type StateClass = "initial" | "active" | "action_required" | "waiting" | "terminal" | "exception";
+interface StateDefinition {
+    id: string;
+    label: string;
+    stateClass: StateClass;
+}
+
+export { type StateClass, type StateDefinition, type StateMachineDatabaseClient, type StateMachineDefinition, type TransitionContext, getAllowedTransitions, getEntityStateClass, registerStateMachine, registerStateMachineIfMissing, resolveStateMachine, validateTransition };

package/dist/testing/index.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var chunkYZKUEC2J_cjs = require('../chunk-YZKUEC2J.cjs');
+require('../chunk-NPVIFZQV.cjs');
+
+
+
+Object.defineProperty(exports, "createDeterministicIdFactory", {
+  enumerable: true,
+  get: function () { return chunkYZKUEC2J_cjs.createDeterministicIdFactory; }
+});
+Object.defineProperty(exports, "createFakeActionContext", {
+  enumerable: true,
+  get: function () { return chunkYZKUEC2J_cjs.createFakeActionContext; }
+});
+Object.defineProperty(exports, "createInMemoryAdapterRegistry", {
+  enumerable: true,
+  get: function () { return chunkYZKUEC2J_cjs.createInMemoryAdapterRegistry; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/testing/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}