@cullet/erp-core 1.0.11 → 1.1.0

package/dist/temporal-use-case.d.ts

@@ -0,0 +1,309 @@
+import { I as Result } from "./gate-types.js";
+import { t as AppError } from "./app-error.js";
+import { b as ContextSeed, r as PolicyEvaluationResult, s as PolicyEvaluationError, t as EvaluateInput } from "./policy-service.js";
+
+//#region src/core/versioning/version.d.ts
+type ContractVersion = `${number}.${number}`;
+//#endregion
+//#region src/core/application/ports/logger.port.d.ts
+type LogPayload = Record<string, unknown>;
+interface LoggerPort {
+  debug(message: string, payload?: LogPayload): void;
+  info(message: string, payload?: LogPayload): void;
+  warn(message: string, payload?: LogPayload): void;
+  error(message: string, payload?: LogPayload): void;
+}
+//#endregion
+//#region src/core/application/ports/metrics.port.d.ts
+type MetricLabels = Readonly<Record<string, string | number | boolean>>;
+interface MetricsPort {
+  counter(name: string, value: number, labels?: MetricLabels): void;
+  gauge(name: string, value: number, labels?: MetricLabels): void;
+  histogram(name: string, value: number, labels?: MetricLabels): void;
+}
+//#endregion
+//#region src/core/application/ports/tracer.port.d.ts
+type TraceAttributeValue = string | number | boolean;
+interface TraceSpan {
+  setAttribute(key: string, value: TraceAttributeValue): void;
+  recordException(error: unknown): void;
+  end(): void;
+}
+interface TracerPort {
+  startSpan(name: string, attributes?: Record<string, TraceAttributeValue>): TraceSpan;
+}
+//#endregion
+//#region src/core/application/use-case.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Observability adapters a use case may opt into.
+ *
+ * All fields are optional: a use case that provides none keeps the plain
+ * `input → Result` behavior with zero overhead. When provided, {@link UseCase.run}
+ * instruments every execution around `execute()` — opening a span, recording
+ * duration, counting outcomes, and logging business/unexpected failures.
+ */
+interface UseCaseObservability {
+  readonly logger?: LoggerPort;
+  readonly metrics?: MetricsPort;
+  readonly tracer?: TracerPort;
+}
+declare abstract class UseCase<Input = void, Output extends Result<unknown, unknown> = Result<void, never>> {
+  static readonly CONTRACT_VERSION: ContractVersion;
+  get contractVersion(): ContractVersion;
+  /**
+   * Runs the use case.
+   *
+   * `run()` is the single seam every use case crosses, so it is where
+   * cross-cutting instrumentation lives. When {@link observability} exposes
+   * any adapter, the call to `execute()` is wrapped with tracing, metrics and
+   * failure logging; otherwise it delegates directly with no overhead.
+   *
+   * Observability is strictly side-effecting: a misbehaving adapter never
+   * changes the business result nor masks a thrown error — its own failures
+   * are swallowed.
+   */
+  run(input: Input): Promise<Output>;
+  /**
+   * Adapters used to instrument {@link run}. Override to opt a use case into
+   * tracing/metrics/logging. Returns an empty object by default, which keeps
+   * the plain delegating behavior.
+   */
+  protected observability(): UseCaseObservability;
+  /**
+   * Stable identity used for span names and metric labels. Defaults to the
+   * runtime class name; override when bundling/minification would otherwise
+   * erase a meaningful name.
+   */
+  protected get useCaseName(): string;
+  protected abstract execute(input: Input): MaybePromise<Output>;
+  private runInstrumented;
+}
+//#endregion
+//#region src/core/application/commands/requested-by.d.ts
+type RequestedByKind = "user" | "system";
+declare class RequestedBy {
+  readonly kind: RequestedByKind;
+  readonly raw: string;
+  private constructor();
+  /** Builds from a human user ID (must be a UUID). */
+  static fromUser(userId: string): RequestedBy;
+  /**
+   * Builds from a system identity.
+   * Only accepts the format "system:<job>", where <job> matches [a-z][a-z0-9]*(-[a-z0-9]+)*.
+   */
+  static fromSystem(systemIdentity: string): RequestedBy;
+  /**
+   * Infers the kind from the raw value.
+   * Use when the origin (user vs system) is not known at the call-site.
+   */
+  static parse(raw: string): RequestedBy;
+  get isUser(): boolean;
+  get isSystem(): boolean;
+  toString(): string;
+}
+//#endregion
+//#region src/core/application/commands/command.d.ts
+interface CommandInput {
+  readonly requestedBy: RequestedBy;
+}
+/**
+ * Base for use cases that **mutate state** (writes), following CQS.
+ *
+ * - `Input extends CommandInput` ensures every mutation records who triggered it.
+ * - `Output extends Result<unknown, unknown>` ensures business errors are
+ *   explicit values, never thrown exceptions.
+ *
+ * The Command/Query distinction is semantic: the type declares the intent
+ * before any implementation exists, guiding code review and API contracts.
+ */
+declare abstract class Command<Input extends CommandInput, Output extends Result<unknown, unknown> = Result<void, never>> extends UseCase<Input, Output> {}
+//#endregion
+//#region src/core/application/ports/policy-port.d.ts
+type PolicyEvaluationInput = EvaluateInput;
+type PolicyEvaluationOutput = PolicyEvaluationResult;
+/**
+ * Failure surfaced by {@link PolicyPort.evaluate}.
+ *
+ * This is the *post-mapping* boundary: the structured `PolicyEvaluationError`
+ * union produced inside the policies module is expected to have already been
+ * translated into an {@link AppError} (e.g. via `mapPolicyEvaluationError`)
+ * before it reaches a use case. Named distinctly from the policies-layer
+ * `PolicyEvaluationError` to avoid a collision on the public surface.
+ */
+type PolicyPortError = AppError;
+interface PolicyPort {
+  evaluate(input: PolicyEvaluationInput): Promise<Result<PolicyEvaluationOutput, PolicyPortError>>;
+}
+//#endregion
+//#region src/core/application/ports/repository.port.d.ts
+/**
+ * Persistence port for an aggregate in the imperative style: absence is
+ * modelled as `null`, and failures (missing row on delete, optimistic
+ * concurrency conflicts, infrastructure errors) surface as thrown exceptions.
+ *
+ * Prefer {@link ResultRepository} when you want those persistence outcomes to
+ * be explicit, recoverable values rather than exceptions.
+ */
+interface Repository<TEntity, TId> {
+  findById(id: TId): Promise<TEntity | null>;
+  save(entity: TEntity): Promise<void>;
+  delete(id: TId): Promise<void>;
+}
+/**
+ * `Result`-returning counterpart of {@link Repository}, aligned with the
+ * "errors as values" philosophy used by `Command` / `UseCase`.
+ *
+ * Where {@link Repository} returns `Promise<void>` from `save`/`delete` and
+ * relies on thrown exceptions, this variant lets a repository *signal*
+ * recoverable persistence outcomes without breaking control flow — for
+ * example a `NotFoundError` when updating/deleting a missing aggregate, or a
+ * `ConflictError` on an optimistic-concurrency version mismatch. A successful
+ * write resolves to `Result.ok(undefined)`.
+ *
+ * `findById` keeps `null` as the "not present" answer to a lookup (not an
+ * error) while still wrapping the call in a `Result` so genuine failures
+ * (e.g. a connectivity error) stay in band.
+ *
+ * `TError` defaults to {@link AppError} to match the rest of the application
+ * boundary (see `PolicyPortError`); narrow it per repository when the failure
+ * set is known, e.g. `ResultRepository<Order, OrderId, NotFoundError | ConflictError>`.
+ */
+interface ResultRepository<TEntity, TId, TError = AppError> {
+  findById(id: TId): Promise<Result<TEntity | null, TError>>;
+  save(entity: TEntity): Promise<Result<void, TError>>;
+  delete(id: TId): Promise<Result<void, TError>>;
+}
+//#endregion
+//#region src/core/domain/temporal/transaction-time.d.ts
+/**
+ * Represents transaction time (Transaction Time).
+ * Defines when the system learned about or recorded a piece of information.
+ * Useful for auditing and reconstructing system state at a specific past moment.
+ */
+interface TransactionTime {
+  /** When the information was first recorded in the system. */
+  readonly recordedAt: Date;
+  /** When this information was superseded or invalidated by a newer version. */
+  readonly supersededAt?: Date;
+}
+//#endregion
+//#region src/core/domain/temporal/valid-time.d.ts
+/**
+ * Represents business time (Valid Time).
+ * Defines when a piece of information is considered true or in effect in the real world.
+ */
+interface ValidTime {
+  /** Start of the validity window (inclusive). */
+  readonly from: Date;
+  /** End of the validity window (exclusive). When absent, the information is still in effect. */
+  readonly to?: Date;
+}
+//#endregion
+//#region src/core/shared/immutable.d.ts
+type PrimitiveValue = bigint | boolean | null | number | string | symbol | undefined;
+type DeepReadonly<T> = T extends PrimitiveValue | Date ? T : T extends readonly (infer TItem)[] ? readonly DeepReadonly<TItem>[] : { readonly [TKey in keyof T]: DeepReadonly<T[TKey]> };
+//#endregion
+//#region src/core/domain/temporal/temporal-snapshot.d.ts
+/**
+ * Pairs a domain datum with its time dimensions (Business and Transaction).
+ * It is the representation of an entry in the append-only (historical) table.
+ */
+interface TemporalSnapshot<T> {
+  /** The data or state captured by the snapshot. */
+  readonly data: DeepReadonly<T>;
+  /** Period during which this datum was valid in the real world. */
+  readonly validTime: ValidTime;
+  /** Period during which this record was the state known to the system. */
+  readonly txTime: TransactionTime;
+}
+//#endregion
+//#region src/core/application/ports/temporal-repository.port.d.ts
+type TemporalHistory<TEntity> = readonly TemporalSnapshot<TEntity>[];
+interface TemporalRepository<TEntity, TId> extends Repository<TEntity, TId> {
+  findAsOf(id: TId, asOf: Date): Promise<TEntity | null>;
+  findAtTransaction(id: TId, txTime: Date): Promise<TEntity | null>;
+  findHistory(id: TId): Promise<TemporalHistory<TEntity>>;
+  save(entity: TEntity, validFrom?: Date): Promise<void>;
+}
+//#endregion
+//#region src/core/application/policy-error-mapper.d.ts
+declare function mapPolicyEvaluationError(err: PolicyEvaluationError): AppError;
+//#endregion
+//#region src/core/application/queries/query.d.ts
+/**
+ * Paginated result of a list query.
+ * Use as `Output` when the query returns a collection with pagination metadata.
+ */
+interface Page<T> {
+  readonly items: readonly T[];
+  readonly total: number;
+  readonly page: number;
+  readonly pageSize: number;
+}
+/**
+ * Cache strategy declared by the query type.
+ * Infrastructure reads this value to decide whether and how to cache the result.
+ */
+type CacheStrategy = {
+  readonly kind: "NO_CACHE";
+} | {
+  readonly kind: "TIME_TO_LIVE";
+  readonly ttlMs: number;
+} | {
+  readonly kind: "STALE_WHILE_REVALIDATE";
+  readonly ttlMs: number;
+};
+type QueryOutput = object | string | number | boolean | bigint | symbol | null;
+/**
+ * Base for use cases that **only read state**, with no side effects, following CQS.
+ *
+ * - `Data extends QueryOutput` prevents a query from declaring a `void` or
+ *   `undefined` success payload, while still allowing primitive projections
+ *   and `null` when that makes sense for the read. Failures stay explicit in
+ *   `Result<T, E>`.
+ * - Override `cacheStrategy()` to declare how infrastructure should cache the
+ *   result. By default, no cache is applied.
+ *
+ * A Query must never mutate persisted data — its execution must be idempotent
+ * and safe to call multiple times with the same input.
+ */
+declare abstract class Query<Input = void, Data extends QueryOutput = never, Failure = AppError> extends UseCase<Input, Result<Data, Failure>> {
+  protected cacheStrategy(): CacheStrategy;
+}
+//#endregion
+//#region src/core/application/temporal/temporal-context.d.ts
+interface TemporalContext {
+  readonly asOf: Date;
+  readonly requestedAt: Date;
+}
+interface CreateTemporalContextInput {
+  readonly asOf?: Date;
+  readonly requestedAt?: Date;
+}
+declare function assertTemporalContext(temporalContext: TemporalContext, fieldName?: string): void;
+declare function createTemporalContext(input?: CreateTemporalContextInput): TemporalContext;
+//#endregion
+//#region src/core/application/temporal/temporal-use-case.d.ts
+interface TemporalUseCaseInput {
+  readonly temporalContext?: TemporalContext;
+}
+/**
+ * A {@link ContextSeed} after temporal enrichment by
+ * {@link TemporalUseCase.buildPolicySeed}: structurally identical to `TSeed`,
+ * except `fields.now` is now guaranteed present as a `Date` (injected from the
+ * resolved {@link TemporalContext}). Downstream policies can therefore read
+ * `seed.fields.now` without a presence/type guard.
+ */
+type TemporalizedContextSeed<TSeed extends ContextSeed> = Omit<TSeed, "fields"> & {
+  readonly fields: TSeed["fields"] & {
+    readonly now: Date;
+  };
+};
+declare abstract class TemporalUseCase<Input extends object, Output extends Result<unknown, unknown>> extends UseCase<Input & TemporalUseCaseInput, Output> {
+  protected resolveTemporalContext(input: Input & TemporalUseCaseInput): TemporalContext;
+  protected buildPolicySeed<TSeed extends ContextSeed>(seed: TSeed, temporalContext: TemporalContext): TemporalizedContextSeed<TSeed>;
+}
+//#endregion
+export { TracerPort as A, RequestedBy as C, UseCaseObservability as D, UseCase as E, ContractVersion as F, MetricsPort as M, LogPayload as N, TraceAttributeValue as O, LoggerPort as P, CommandInput as S, MaybePromise as T, PolicyEvaluationInput as _, TemporalContext as a, PolicyPortError as b, CacheStrategy as c, mapPolicyEvaluationError as d, TemporalHistory as f, ResultRepository as g, Repository as h, CreateTemporalContextInput as i, MetricLabels as j, TraceSpan as k, Page as l, DeepReadonly as m, TemporalUseCaseInput as n, assertTemporalContext as o, TemporalRepository as p, TemporalizedContextSeed as r, createTemporalContext as s, TemporalUseCase as t, Query as u, PolicyEvaluationOutput as v, RequestedByKind as w, Command as x, PolicyPort as y };
+//# sourceMappingURL=temporal-use-case.d.ts.map

package/dist/temporal-use-case.js

@@ -0,0 +1,284 @@
+import { n as UnexpectedError, t as ValidationCode } from "./validation-code.js";
+import { n as BusinessRuleViolationError, t as NotFoundError } from "./not-found-error.js";
+import { t as ValidationField } from "./validation-field.js";
+import { i as InvariantViolationException, t as assertValidDate } from "./temporal-guards.js";
+import { t as InvalidValueException } from "./validation-exception.js";
+//#region src/core/versioning/version.ts
+const CONTRACT_VERSION_PROPERTY = "CONTRACT_VERSION";
+const CONTRACT_VERSION_PATTERN = /^\d+\.\d+$/;
+function version(contractVersion) {
+	if (!CONTRACT_VERSION_PATTERN.test(contractVersion)) throw new TypeError(`Invalid contract version "${contractVersion}". Expected MAJOR.MINOR.`);
+	return (target) => {
+		Object.defineProperty(target, CONTRACT_VERSION_PROPERTY, {
+			value: contractVersion,
+			writable: false,
+			configurable: false,
+			enumerable: false
+		});
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.132.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/core/application/use-case.ts
+var _UseCase;
+const EXECUTION_COUNTER = "use_case.executions";
+const DURATION_HISTOGRAM = "use_case.duration_ms";
+let UseCase = class UseCase {
+	static {
+		_UseCase = this;
+	}
+	get contractVersion() {
+		return _UseCase.CONTRACT_VERSION;
+	}
+	/**
+	* Runs the use case.
+	*
+	* `run()` is the single seam every use case crosses, so it is where
+	* cross-cutting instrumentation lives. When {@link observability} exposes
+	* any adapter, the call to `execute()` is wrapped with tracing, metrics and
+	* failure logging; otherwise it delegates directly with no overhead.
+	*
+	* Observability is strictly side-effecting: a misbehaving adapter never
+	* changes the business result nor masks a thrown error — its own failures
+	* are swallowed.
+	*/
+	async run(input) {
+		const observability = this.observability();
+		if (!observability.logger && !observability.metrics && !observability.tracer) return await this.execute(input);
+		return await this.runInstrumented(input, observability);
+	}
+	/**
+	* Adapters used to instrument {@link run}. Override to opt a use case into
+	* tracing/metrics/logging. Returns an empty object by default, which keeps
+	* the plain delegating behavior.
+	*/
+	observability() {
+		return {};
+	}
+	/**
+	* Stable identity used for span names and metric labels. Defaults to the
+	* runtime class name; override when bundling/minification would otherwise
+	* erase a meaningful name.
+	*/
+	get useCaseName() {
+		return this.constructor.name;
+	}
+	async runInstrumented(input, observability) {
+		const { logger, metrics, tracer } = observability;
+		const name = this.useCaseName;
+		const span = safely(() => tracer?.startSpan(name, { "use_case.name": name }));
+		const startedAt = Date.now();
+		try {
+			const output = await this.execute(input);
+			const outcome = output.isOk() ? "ok" : "error";
+			if (outcome === "error") safely(() => logger?.warn(`${name} returned a business error`, { useCase: name }));
+			safely(() => span?.setAttribute("use_case.outcome", outcome));
+			safely(() => metrics?.counter(EXECUTION_COUNTER, 1, {
+				useCase: name,
+				outcome
+			}));
+			return output;
+		} catch (error) {
+			safely(() => logger?.error(`${name} threw an unexpected error`, { useCase: name }));
+			safely(() => span?.setAttribute("use_case.outcome", "exception"));
+			safely(() => span?.recordException(error));
+			safely(() => metrics?.counter(EXECUTION_COUNTER, 1, {
+				useCase: name,
+				outcome: "exception"
+			}));
+			throw error;
+		} finally {
+			safely(() => metrics?.histogram(DURATION_HISTOGRAM, Date.now() - startedAt, { useCase: name }));
+			safely(() => span?.end());
+		}
+	}
+};
+UseCase = _UseCase = __decorate([version("1.0")], UseCase);
+/**
+* Invokes an observability side effect, isolating any adapter failure so it
+* cannot alter the use case outcome.
+*/
+function safely(effect) {
+	try {
+		return effect();
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/core/application/commands/requested-by.ts
+const REQUESTED_BY_FIELD = ValidationField.of("requestedBy");
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SYSTEM_IDENTITY_PATTERN = /^system:[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var RequestedBy = class RequestedBy {
+	constructor(kind, raw) {
+		this.kind = kind;
+		this.raw = raw;
+		Object.freeze(this);
+	}
+	/** Builds from a human user ID (must be a UUID). */
+	static fromUser(userId) {
+		if (!UUID_PATTERN.test(userId)) throw new InvalidValueException(REQUESTED_BY_FIELD, ValidationCode.INVALID_FORMAT, `requestedBy: user identity must be a UUID, got "${userId}"`);
+		return new RequestedBy("user", userId);
+	}
+	/**
+	* Builds from a system identity.
+	* Only accepts the format "system:<job>", where <job> matches [a-z][a-z0-9]*(-[a-z0-9]+)*.
+	*/
+	static fromSystem(systemIdentity) {
+		if (!SYSTEM_IDENTITY_PATTERN.test(systemIdentity)) throw new InvalidValueException(REQUESTED_BY_FIELD, ValidationCode.INVALID_FORMAT, `requestedBy: system identity must match "system:<job>" (e.g. "system:late-fee-job"), got "${systemIdentity}"`);
+		return new RequestedBy("system", systemIdentity);
+	}
+	/**
+	* Infers the kind from the raw value.
+	* Use when the origin (user vs system) is not known at the call-site.
+	*/
+	static parse(raw) {
+		if (UUID_PATTERN.test(raw)) return new RequestedBy("user", raw);
+		if (SYSTEM_IDENTITY_PATTERN.test(raw)) return new RequestedBy("system", raw);
+		throw new InvalidValueException(REQUESTED_BY_FIELD, ValidationCode.INVALID_FORMAT, `requestedBy must be a UUID (user) or "system:<job>" (system), got "${raw}"`);
+	}
+	get isUser() {
+		return this.kind === "user";
+	}
+	get isSystem() {
+		return this.kind === "system";
+	}
+	toString() {
+		return this.raw;
+	}
+};
+//#endregion
+//#region src/core/application/commands/command.ts
+/**
+* Base for use cases that **mutate state** (writes), following CQS.
+*
+* - `Input extends CommandInput` ensures every mutation records who triggered it.
+* - `Output extends Result<unknown, unknown>` ensures business errors are
+*   explicit values, never thrown exceptions.
+*
+* The Command/Query distinction is semantic: the type declares the intent
+* before any implementation exists, guiding code review and API contracts.
+*/
+let Command = class Command extends UseCase {};
+Command = __decorate([version("1.0")], Command);
+//#endregion
+//#region src/core/application/policy-error-mapper.ts
+function mapPolicyEvaluationError(err) {
+	switch (err.kind) {
+		case "INVALID_CONTEXT": return new BusinessRuleViolationError(`policy.${err.stage.toLowerCase()}`, err.message, {
+			policyKey: err.policyKey,
+			stage: err.stage
+		}, { cause: err.cause });
+		case "INVALID_POLICY_KEY": return new BusinessRuleViolationError("policy.invalid_key", err.message, { rawPolicyKey: err.rawPolicyKey }, { cause: err.cause });
+		case "POLICY_NOT_FOUND": return new NotFoundError("Policy", { policyKey: err.policyKey }, { cause: err.cause });
+		case "POLICY_DEFINITION_NOT_FOUND": return new NotFoundError("PolicyDefinition", {
+			policyKey: err.policyKey,
+			contextVersion: err.contextVersion,
+			asOf: err.asOf.toISOString()
+		}, { cause: err.cause });
+		case "POLICY_VARIANT_NOT_FOUND": return new NotFoundError("PolicyVariant", {
+			policyKey: err.policyKey,
+			policyKind: err.policyKind,
+			payloadSchemaVersion: err.payloadSchemaVersion
+		}, { cause: err.cause });
+		case "ENGINE_FAILURE": return new UnexpectedError(err.message, err.cause, { metadata: {
+			policyKey: err.policyKey,
+			engine: err.engine,
+			engineVersion: err.engineVersion
+		} });
+	}
+}
+//#endregion
+//#region src/core/application/queries/query.ts
+/**
+* Base for use cases that **only read state**, with no side effects, following CQS.
+*
+* - `Data extends QueryOutput` prevents a query from declaring a `void` or
+*   `undefined` success payload, while still allowing primitive projections
+*   and `null` when that makes sense for the read. Failures stay explicit in
+*   `Result<T, E>`.
+* - Override `cacheStrategy()` to declare how infrastructure should cache the
+*   result. By default, no cache is applied.
+*
+* A Query must never mutate persisted data — its execution must be idempotent
+* and safe to call multiple times with the same input.
+*/
+let Query = class Query extends UseCase {
+	cacheStrategy() {
+		return { kind: "NO_CACHE" };
+	}
+};
+Query = __decorate([version("1.0")], Query);
+//#endregion
+//#region src/core/shared/immutable.ts
+function deepFreeze(value) {
+	return deepFreezeInternal(value, /* @__PURE__ */ new WeakSet());
+}
+function deepFreezeInternal(value, seen) {
+	if (typeof value !== "object" || value === null || value instanceof Date) return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		for (const item of value) deepFreezeInternal(item, seen);
+		return Object.freeze(value);
+	}
+	const objectValue = value;
+	for (const propertyKey of Reflect.ownKeys(objectValue)) deepFreezeInternal(objectValue[propertyKey], seen);
+	return Object.freeze(value);
+}
+function makeImmutable(value) {
+	if (typeof value !== "object" || value === null) return value;
+	let snapshot;
+	try {
+		snapshot = structuredClone(value);
+	} catch (error) {
+		throw new InvariantViolationException(`makeImmutable requires a structured-cloneable value: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return deepFreeze(snapshot);
+}
+//#endregion
+//#region src/core/application/temporal/temporal-context.ts
+function assertTemporalContext(temporalContext, fieldName = "temporalContext") {
+	assertValidDate(`${fieldName}.asOf`, temporalContext.asOf);
+	assertValidDate(`${fieldName}.requestedAt`, temporalContext.requestedAt);
+}
+function createTemporalContext(input = {}) {
+	const requestedAt = input.requestedAt ?? /* @__PURE__ */ new Date();
+	const asOf = input.asOf ?? requestedAt;
+	assertTemporalContext({
+		asOf,
+		requestedAt
+	});
+	return makeImmutable({
+		asOf,
+		requestedAt
+	});
+}
+//#endregion
+//#region src/core/application/temporal/temporal-use-case.ts
+var TemporalUseCase = class extends UseCase {
+	resolveTemporalContext(input) {
+		return createTemporalContext(input.temporalContext);
+	}
+	buildPolicySeed(seed, temporalContext) {
+		return Object.freeze({
+			...seed,
+			fields: {
+				...seed.fields,
+				now: new Date(temporalContext.requestedAt.getTime())
+			}
+		});
+	}
+};
+//#endregion
+export { Query as a, RequestedBy as c, version as d, makeImmutable as i, UseCase as l, assertTemporalContext as n, mapPolicyEvaluationError as o, createTemporalContext as r, Command as s, TemporalUseCase as t, __decorate as u };
+
+//# sourceMappingURL=temporal-use-case.js.map

package/dist/temporal-use-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-use-case.js","names":[],"sources":["../src/core/versioning/version.ts","../src/core/application/use-case.ts","../src/core/application/commands/requested-by.ts","../src/core/application/commands/command.ts","../src/core/application/policy-error-mapper.ts","../src/core/application/queries/query.ts","../src/core/shared/immutable.ts","../src/core/application/temporal/temporal-context.ts","../src/core/application/temporal/temporal-use-case.ts"],"sourcesContent":["type ContractVersion = `${number}.${number}`;\n\ntype VersionedTarget = {\n    readonly prototype: object;\n};\n\nconst CONTRACT_VERSION_PROPERTY = \"CONTRACT_VERSION\" as const;\nconst CONTRACT_VERSION_PATTERN = /^\\d+\\.\\d+$/;\n\nfunction version<const TVersion extends ContractVersion>(\n    contractVersion: TVersion,\n) {\n    if (!CONTRACT_VERSION_PATTERN.test(contractVersion)) {\n        throw new TypeError(\n            `Invalid contract version \"${contractVersion}\". Expected MAJOR.MINOR.`,\n        );\n    }\n\n    return (target: VersionedTarget): void => {\n        Object.defineProperty(target, CONTRACT_VERSION_PROPERTY, {\n            value: contractVersion,\n            writable: false,\n            configurable: false,\n            enumerable: false,\n        });\n    };\n}\n\nexport {\n    CONTRACT_VERSION_PROPERTY,\n    type ContractVersion,\n    version,\n    type VersionedTarget,\n};\n","import { type ContractVersion, version } from \"../versioning/version.js\";\nimport type { Result } from \"../result/result.js\";\n\nimport type { LoggerPort } from \"./ports/logger.port.js\";\nimport type { MetricsPort } from \"./ports/metrics.port.js\";\nimport type { TracerPort } from \"./ports/tracer.port.js\";\n\ntype MaybePromise<T> = T | Promise<T>;\n\n/**\n * Observability adapters a use case may opt into.\n *\n * All fields are optional: a use case that provides none keeps the plain\n * `input → Result` behavior with zero overhead. When provided, {@link UseCase.run}\n * instruments every execution around `execute()` — opening a span, recording\n * duration, counting outcomes, and logging business/unexpected failures.\n */\ninterface UseCaseObservability {\n    readonly logger?: LoggerPort;\n    readonly metrics?: MetricsPort;\n    readonly tracer?: TracerPort;\n}\n\nconst EXECUTION_COUNTER = \"use_case.executions\";\nconst DURATION_HISTOGRAM = \"use_case.duration_ms\";\n\ntype ExecutionOutcome = \"ok\" | \"error\" | \"exception\";\n\n@version(\"1.0\")\nabstract class UseCase<\n    Input = void,\n    Output extends Result<unknown, unknown> = Result<void, never>,\n> {\n    declare public static readonly CONTRACT_VERSION: ContractVersion;\n\n    public get contractVersion(): ContractVersion {\n        return UseCase.CONTRACT_VERSION;\n    }\n\n    /**\n     * Runs the use case.\n     *\n     * `run()` is the single seam every use case crosses, so it is where\n     * cross-cutting instrumentation lives. When {@link observability} exposes\n     * any adapter, the call to `execute()` is wrapped with tracing, metrics and\n     * failure logging; otherwise it delegates directly with no overhead.\n     *\n     * Observability is strictly side-effecting: a misbehaving adapter never\n     * changes the business result nor masks a thrown error — its own failures\n     * are swallowed.\n     */\n    public async run(input: Input): Promise<Output> {\n        const observability = this.observability();\n        if (\n            !observability.logger &&\n            !observability.metrics &&\n            !observability.tracer\n        ) {\n            return await this.execute(input);\n        }\n\n        return await this.runInstrumented(input, observability);\n    }\n\n    /**\n     * Adapters used to instrument {@link run}. Override to opt a use case into\n     * tracing/metrics/logging. Returns an empty object by default, which keeps\n     * the plain delegating behavior.\n     */\n    protected observability(): UseCaseObservability {\n        return {};\n    }\n\n    /**\n     * Stable identity used for span names and metric labels. Defaults to the\n     * runtime class name; override when bundling/minification would otherwise\n     * erase a meaningful name.\n     */\n    protected get useCaseName(): string {\n        return this.constructor.name;\n    }\n\n    protected abstract execute(input: Input): MaybePromise<Output>;\n\n    private async runInstrumented(\n        input: Input,\n        observability: UseCaseObservability,\n    ): Promise<Output> {\n        const { logger, metrics, tracer } = observability;\n        const name = this.useCaseName;\n        const span = safely(() =>\n            tracer?.startSpan(name, { \"use_case.name\": name }),\n        );\n        const startedAt = Date.now();\n\n        try {\n            const output = await this.execute(input);\n            const outcome: ExecutionOutcome = output.isOk() ? \"ok\" : \"error\";\n\n            if (outcome === \"error\") {\n                safely(() =>\n                    logger?.warn(`${name} returned a business error`, {\n                        useCase: name,\n                    }),\n                );\n            }\n            safely(() => span?.setAttribute(\"use_case.outcome\", outcome));\n            safely(() =>\n                metrics?.counter(EXECUTION_COUNTER, 1, {\n                    useCase: name,\n                    outcome,\n                }),\n            );\n\n            return output;\n        } catch (error) {\n            safely(() =>\n                logger?.error(`${name} threw an unexpected error`, {\n                    useCase: name,\n                }),\n            );\n            safely(() => span?.setAttribute(\"use_case.outcome\", \"exception\"));\n            safely(() => span?.recordException(error));\n            safely(() =>\n                metrics?.counter(EXECUTION_COUNTER, 1, {\n                    useCase: name,\n                    outcome: \"exception\",\n                }),\n            );\n\n            throw error;\n        } finally {\n            safely(() =>\n                metrics?.histogram(DURATION_HISTOGRAM, Date.now() - startedAt, {\n                    useCase: name,\n                }),\n            );\n            safely(() => span?.end());\n        }\n    }\n}\n\n/**\n * Invokes an observability side effect, isolating any adapter failure so it\n * cannot alter the use case outcome.\n */\nfunction safely<R>(effect: () => R): R | undefined {\n    try {\n        return effect();\n    } catch {\n        return undefined;\n    }\n}\n\nexport { type MaybePromise, UseCase, type UseCaseObservability };\n","import { ValidationCode } from \"../../exceptions/validation-code.js\";\nimport { InvalidValueException } from \"../../exceptions/validation-exception.js\";\nimport { ValidationField } from \"../../exceptions/validation-field.js\";\n\n// Identifies who triggered a Command.\n// Two valid formats:\n//   - Human user: UUID v4 (e.g.: \"550e8400-e29b-41d4-a716-446655440000\")\n//   - System identity: \"system:<job>\" where <job> is [a-z][a-z0-9]*(-[a-z0-9]+)*\n//     (e.g.: \"system:late-fee-job\", \"system:email-sender\")\n//\n// The split between `fromUser` / `fromSystem` / `parse` exists to make intent\n// explicit at the call-site: whoever builds the value knows where it came from.\n\ntype RequestedByKind = \"user\" | \"system\";\n\nconst REQUESTED_BY_FIELD = ValidationField.of(\"requestedBy\");\n\nconst UUID_PATTERN =\n    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n// system:<job> where <job> starts with a lowercase letter and may have hyphens between segments\nconst SYSTEM_IDENTITY_PATTERN = /^system:[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;\n\nclass RequestedBy {\n    readonly kind: RequestedByKind;\n    readonly raw: string;\n\n    private constructor(kind: RequestedByKind, raw: string) {\n        this.kind = kind;\n        this.raw = raw;\n        Object.freeze(this);\n    }\n\n    /** Builds from a human user ID (must be a UUID). */\n    static fromUser(userId: string): RequestedBy {\n        if (!UUID_PATTERN.test(userId)) {\n            throw new InvalidValueException(\n                REQUESTED_BY_FIELD,\n                ValidationCode.INVALID_FORMAT,\n                `requestedBy: user identity must be a UUID, got \"${userId}\"`,\n            );\n        }\n\n        return new RequestedBy(\"user\", userId);\n    }\n\n    /**\n     * Builds from a system identity.\n     * Only accepts the format \"system:<job>\", where <job> matches [a-z][a-z0-9]*(-[a-z0-9]+)*.\n     */\n    static fromSystem(systemIdentity: string): RequestedBy {\n        if (!SYSTEM_IDENTITY_PATTERN.test(systemIdentity)) {\n            throw new InvalidValueException(\n                REQUESTED_BY_FIELD,\n                ValidationCode.INVALID_FORMAT,\n                `requestedBy: system identity must match \"system:<job>\" (e.g. \"system:late-fee-job\"), got \"${systemIdentity}\"`,\n            );\n        }\n\n        return new RequestedBy(\"system\", systemIdentity);\n    }\n\n    /**\n     * Infers the kind from the raw value.\n     * Use when the origin (user vs system) is not known at the call-site.\n     */\n    static parse(raw: string): RequestedBy {\n        if (UUID_PATTERN.test(raw)) {\n            return new RequestedBy(\"user\", raw);\n        }\n\n        if (SYSTEM_IDENTITY_PATTERN.test(raw)) {\n            return new RequestedBy(\"system\", raw);\n        }\n\n        throw new InvalidValueException(\n            REQUESTED_BY_FIELD,\n            ValidationCode.INVALID_FORMAT,\n            `requestedBy must be a UUID (user) or \"system:<job>\" (system), got \"${raw}\"`,\n        );\n    }\n\n    get isUser(): boolean {\n        return this.kind === \"user\";\n    }\n\n    get isSystem(): boolean {\n        return this.kind === \"system\";\n    }\n\n    toString(): string {\n        return this.raw;\n    }\n}\n\nexport type { RequestedByKind };\nexport { RequestedBy };\n","import { UseCase } from \"../use-case.js\";\nimport { version } from \"../../versioning/version.js\";\nimport type { Result } from \"../../result/result.js\";\n\nimport { RequestedBy } from \"./requested-by.js\";\n\ninterface CommandInput {\n    readonly requestedBy: RequestedBy;\n}\n\n/**\n * Base for use cases that **mutate state** (writes), following CQS.\n *\n * - `Input extends CommandInput` ensures every mutation records who triggered it.\n * - `Output extends Result<unknown, unknown>` ensures business errors are\n *   explicit values, never thrown exceptions.\n *\n * The Command/Query distinction is semantic: the type declares the intent\n * before any implementation exists, guiding code review and API contracts.\n */\n@version(\"1.0\")\nabstract class Command<\n    Input extends CommandInput,\n    Output extends Result<unknown, unknown> = Result<void, never>,\n> extends UseCase<Input, Output> {}\n\nexport type { CommandInput };\nexport { Command };\n","import {\n    type AppError,\n    BusinessRuleViolationError,\n    NotFoundError,\n    UnexpectedError,\n} from \"../errors/index.js\";\nimport type { PolicyEvaluationError } from \"../policies/index.js\";\n\nexport function mapPolicyEvaluationError(err: PolicyEvaluationError): AppError {\n    switch (err.kind) {\n        case \"INVALID_CONTEXT\":\n            return new BusinessRuleViolationError(\n                `policy.${err.stage.toLowerCase()}`,\n                err.message,\n                { policyKey: err.policyKey, stage: err.stage },\n                { cause: err.cause },\n            );\n        case \"INVALID_POLICY_KEY\":\n            return new BusinessRuleViolationError(\n                \"policy.invalid_key\",\n                err.message,\n                { rawPolicyKey: err.rawPolicyKey },\n                { cause: err.cause },\n            );\n        case \"POLICY_NOT_FOUND\":\n            return new NotFoundError(\n                \"Policy\",\n                { policyKey: err.policyKey },\n                { cause: err.cause },\n            );\n        case \"POLICY_DEFINITION_NOT_FOUND\":\n            return new NotFoundError(\n                \"PolicyDefinition\",\n                {\n                    policyKey: err.policyKey,\n                    contextVersion: err.contextVersion,\n                    asOf: err.asOf.toISOString(),\n                },\n                { cause: err.cause },\n            );\n        case \"POLICY_VARIANT_NOT_FOUND\":\n            return new NotFoundError(\n                \"PolicyVariant\",\n                {\n                    policyKey: err.policyKey,\n                    policyKind: err.policyKind,\n                    payloadSchemaVersion: err.payloadSchemaVersion,\n                },\n                { cause: err.cause },\n            );\n        case \"ENGINE_FAILURE\":\n            return new UnexpectedError(err.message, err.cause, {\n                metadata: {\n                    policyKey: err.policyKey,\n                    engine: err.engine,\n                    engineVersion: err.engineVersion,\n                },\n            });\n    }\n}\n","import { UseCase } from \"../use-case.js\";\nimport { version } from \"../../versioning/version.js\";\nimport type { AppError } from \"../../errors/index.js\";\nimport type { Result } from \"../../result/result.js\";\n\n/**\n * Paginated result of a list query.\n * Use as `Output` when the query returns a collection with pagination metadata.\n */\ninterface Page<T> {\n    readonly items: readonly T[];\n    readonly total: number;\n    readonly page: number;\n    readonly pageSize: number;\n}\n\n/**\n * Cache strategy declared by the query type.\n * Infrastructure reads this value to decide whether and how to cache the result.\n */\ntype CacheStrategy =\n    | { readonly kind: \"NO_CACHE\" }\n    | { readonly kind: \"TIME_TO_LIVE\"; readonly ttlMs: number }\n    | { readonly kind: \"STALE_WHILE_REVALIDATE\"; readonly ttlMs: number };\n\ntype QueryOutput = object | string | number | boolean | bigint | symbol | null;\n\n/**\n * Base for use cases that **only read state**, with no side effects, following CQS.\n *\n * - `Data extends QueryOutput` prevents a query from declaring a `void` or\n *   `undefined` success payload, while still allowing primitive projections\n *   and `null` when that makes sense for the read. Failures stay explicit in\n *   `Result<T, E>`.\n * - Override `cacheStrategy()` to declare how infrastructure should cache the\n *   result. By default, no cache is applied.\n *\n * A Query must never mutate persisted data — its execution must be idempotent\n * and safe to call multiple times with the same input.\n */\n@version(\"1.0\")\nabstract class Query<\n    Input = void,\n    Data extends QueryOutput = never,\n    Failure = AppError,\n> extends UseCase<Input, Result<Data, Failure>> {\n    protected cacheStrategy(): CacheStrategy {\n        return { kind: \"NO_CACHE\" };\n    }\n}\n\nexport type { CacheStrategy, Page, QueryOutput };\nexport { Query };\n","import { InvariantViolationException } from \"../exceptions/invariant-violation-exception.js\";\n\ntype PrimitiveValue =\n    | bigint\n    | boolean\n    | null\n    | number\n    | string\n    | symbol\n    | undefined;\n\ntype DeepReadonly<T> = T extends PrimitiveValue | Date\n    ? T\n    : T extends readonly (infer TItem)[]\n      ? readonly DeepReadonly<TItem>[]\n      : { readonly [TKey in keyof T]: DeepReadonly<T[TKey]> };\n\nfunction deepFreeze<T>(value: T): T {\n    return deepFreezeInternal(value, new WeakSet<object>());\n}\n\nfunction deepFreezeInternal<T>(value: T, seen: WeakSet<object>): T {\n    // Primitives and `null` need no freezing. `Date` is intentionally returned\n    // as-is: `Object.freeze` cannot stop a Date's mutators (`setTime`,\n    // `setFullYear`, …) because they write an internal slot, not an own\n    // property — freezing it is a no-op against mutation. `makeImmutable`\n    // already hands us a `structuredClone` copy, so the caller's original Date\n    // is never aliased; deep-freezing of nested Dates is deliberately skipped.\n    if (typeof value !== \"object\" || value === null || value instanceof Date) {\n        return value;\n    }\n\n    // A value already on `seen` has been visited on this pass (cyclic graph or a\n    // shared reference); revisiting it would recurse forever.\n    if (seen.has(value)) {\n        return value;\n    }\n    seen.add(value);\n\n    if (Array.isArray(value)) {\n        for (const item of value) {\n            deepFreezeInternal(item, seen);\n        }\n\n        return Object.freeze(value);\n    }\n\n    const objectValue = value as Record<PropertyKey, object | PrimitiveValue>;\n\n    for (const propertyKey of Reflect.ownKeys(objectValue)) {\n        deepFreezeInternal(objectValue[propertyKey], seen);\n    }\n\n    return Object.freeze(value);\n}\n\nfunction makeImmutable<T>(value: T): DeepReadonly<T> {\n    if (typeof value !== \"object\" || value === null) {\n        return value as DeepReadonly<T>;\n    }\n\n    let snapshot: T;\n    try {\n        snapshot = structuredClone(value);\n    } catch (error) {\n        // `structuredClone` throws `DataCloneError` for functions, symbols and\n        // class instances. Surface it as a domain invariant instead of leaking\n        // a host-specific runtime error to callers building value objects.\n        throw new InvariantViolationException(\n            `makeImmutable requires a structured-cloneable value: ${\n                error instanceof Error ? error.message : String(error)\n            }`,\n        );\n    }\n\n    return deepFreeze(snapshot) as DeepReadonly<T>;\n}\n\nexport { deepFreeze, makeImmutable, type DeepReadonly };\n","import { makeImmutable } from \"../../shared/immutable.js\";\nimport { assertValidDate } from \"../../shared/temporal-guards.js\";\n\ninterface TemporalContext {\n    readonly asOf: Date;\n    readonly requestedAt: Date;\n}\n\ninterface CreateTemporalContextInput {\n    readonly asOf?: Date;\n    readonly requestedAt?: Date;\n}\n\nfunction assertTemporalContext(\n    temporalContext: TemporalContext,\n    fieldName: string = \"temporalContext\",\n): void {\n    assertValidDate(`${fieldName}.asOf`, temporalContext.asOf);\n    assertValidDate(`${fieldName}.requestedAt`, temporalContext.requestedAt);\n}\n\nfunction createTemporalContext(\n    input: CreateTemporalContextInput = {},\n): TemporalContext {\n    const requestedAt = input.requestedAt ?? new Date();\n    const asOf = input.asOf ?? requestedAt;\n\n    assertTemporalContext({ asOf, requestedAt });\n\n    return makeImmutable({\n        asOf,\n        requestedAt,\n    });\n}\n\nexport {\n    assertTemporalContext,\n    createTemporalContext,\n    type CreateTemporalContextInput,\n    type TemporalContext,\n};\n","import { UseCase } from \"../use-case.js\";\nimport type { ContextSeed } from \"../../policies/index.js\";\nimport type { Result } from \"../../result/result.js\";\n\nimport {\n    createTemporalContext,\n    type TemporalContext,\n} from \"./temporal-context.js\";\n\ninterface TemporalUseCaseInput {\n    readonly temporalContext?: TemporalContext;\n}\n\n/**\n * A {@link ContextSeed} after temporal enrichment by\n * {@link TemporalUseCase.buildPolicySeed}: structurally identical to `TSeed`,\n * except `fields.now` is now guaranteed present as a `Date` (injected from the\n * resolved {@link TemporalContext}). Downstream policies can therefore read\n * `seed.fields.now` without a presence/type guard.\n */\ntype TemporalizedContextSeed<TSeed extends ContextSeed> = Omit<\n    TSeed,\n    \"fields\"\n> & {\n    readonly fields: TSeed[\"fields\"] & { readonly now: Date };\n};\n\nabstract class TemporalUseCase<\n    Input extends object,\n    Output extends Result<unknown, unknown>,\n> extends UseCase<Input & TemporalUseCaseInput, Output> {\n    protected resolveTemporalContext(\n        input: Input & TemporalUseCaseInput,\n    ): TemporalContext {\n        return createTemporalContext(input.temporalContext);\n    }\n\n    protected buildPolicySeed<TSeed extends ContextSeed>(\n        seed: TSeed,\n        temporalContext: TemporalContext,\n    ): TemporalizedContextSeed<TSeed> {\n        return Object.freeze({\n            ...seed,\n            fields: {\n                ...seed.fields,\n                now: new Date(temporalContext.requestedAt.getTime()),\n            },\n        }) as TemporalizedContextSeed<TSeed>;\n    }\n}\n\nexport type { TemporalizedContextSeed, TemporalUseCaseInput };\nexport { TemporalUseCase };\n"],"mappings":";;;;;;AAMA,MAAM,4BAA4B;AAClC,MAAM,2BAA2B;AAEjC,SAAS,QACL,iBACF;CACE,IAAI,CAAC,yBAAyB,KAAK,eAAe,GAC9C,MAAM,IAAI,UACN,6BAA6B,gBAAgB,yBACjD;CAGJ,QAAQ,WAAkC;EACtC,OAAO,eAAe,QAAQ,2BAA2B;GACrD,OAAO;GACP,UAAU;GACV,cAAc;GACd,YAAY;EAChB,CAAC;CACL;AACJ;;;;;;;;;;;;ACHA,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;AAI3B,IAAA,UAAA,MACe,QAGb;;;;CAGE,IAAW,kBAAmC;EAC1C,OAAA,SAAe;CACnB;;;;;;;;;;;;;CAcA,MAAa,IAAI,OAA+B;EAC5C,MAAM,gBAAgB,KAAK,cAAc;EACzC,IACI,CAAC,cAAc,UACf,CAAC,cAAc,WACf,CAAC,cAAc,QAEf,OAAO,MAAM,KAAK,QAAQ,KAAK;EAGnC,OAAO,MAAM,KAAK,gBAAgB,OAAO,aAAa;CAC1D;;;;;;CAOA,gBAAgD;EAC5C,OAAO,CAAC;CACZ;;;;;;CAOA,IAAc,cAAsB;EAChC,OAAO,KAAK,YAAY;CAC5B;CAIA,MAAc,gBACV,OACA,eACe;EACf,MAAM,EAAE,QAAQ,SAAS,WAAW;EACpC,MAAM,OAAO,KAAK;EAClB,MAAM,OAAO,aACT,QAAQ,UAAU,MAAM,EAAE,iBAAiB,KAAK,CAAC,CACrD;EACA,MAAM,YAAY,KAAK,IAAI;EAE3B,IAAI;GACA,MAAM,SAAS,MAAM,KAAK,QAAQ,KAAK;GACvC,MAAM,UAA4B,OAAO,KAAK,IAAI,OAAO;GAEzD,IAAI,YAAY,SACZ,aACI,QAAQ,KAAK,GAAG,KAAK,6BAA6B,EAC9C,SAAS,KACb,CAAC,CACL;GAEJ,aAAa,MAAM,aAAa,oBAAoB,OAAO,CAAC;GAC5D,aACI,SAAS,QAAQ,mBAAmB,GAAG;IACnC,SAAS;IACT;GACJ,CAAC,CACL;GAEA,OAAO;EACX,SAAS,OAAO;GACZ,aACI,QAAQ,MAAM,GAAG,KAAK,6BAA6B,EAC/C,SAAS,KACb,CAAC,CACL;GACA,aAAa,MAAM,aAAa,oBAAoB,WAAW,CAAC;GAChE,aAAa,MAAM,gBAAgB,KAAK,CAAC;GACzC,aACI,SAAS,QAAQ,mBAAmB,GAAG;IACnC,SAAS;IACT,SAAS;GACb,CAAC,CACL;GAEA,MAAM;EACV,UAAU;GACN,aACI,SAAS,UAAU,oBAAoB,KAAK,IAAI,IAAI,WAAW,EAC3D,SAAS,KACb,CAAC,CACL;GACA,aAAa,MAAM,IAAI,CAAC;EAC5B;CACJ;AACJ;iCAhHC,QAAQ,KAAK,CAAA,GAAA,OAAA;;;;;AAsHd,SAAS,OAAU,QAAgC;CAC/C,IAAI;EACA,OAAO,OAAO;CAClB,QAAQ;EACJ;CACJ;AACJ;;;ACzIA,MAAM,qBAAqB,gBAAgB,GAAG,aAAa;AAE3D,MAAM,eACF;AAGJ,MAAM,0BAA0B;AAEhC,IAAM,cAAN,MAAM,YAAY;CAId,YAAoB,MAAuB,KAAa;EACpD,KAAK,OAAO;EACZ,KAAK,MAAM;EACX,OAAO,OAAO,IAAI;CACtB;;CAGA,OAAO,SAAS,QAA6B;EACzC,IAAI,CAAC,aAAa,KAAK,MAAM,GACzB,MAAM,IAAI,sBACN,oBACA,eAAe,gBACf,mDAAmD,OAAO,EAC9D;EAGJ,OAAO,IAAI,YAAY,QAAQ,MAAM;CACzC;;;;;CAMA,OAAO,WAAW,gBAAqC;EACnD,IAAI,CAAC,wBAAwB,KAAK,cAAc,GAC5C,MAAM,IAAI,sBACN,oBACA,eAAe,gBACf,6FAA6F,eAAe,EAChH;EAGJ,OAAO,IAAI,YAAY,UAAU,cAAc;CACnD;;;;;CAMA,OAAO,MAAM,KAA0B;EACnC,IAAI,aAAa,KAAK,GAAG,GACrB,OAAO,IAAI,YAAY,QAAQ,GAAG;EAGtC,IAAI,wBAAwB,KAAK,GAAG,GAChC,OAAO,IAAI,YAAY,UAAU,GAAG;EAGxC,MAAM,IAAI,sBACN,oBACA,eAAe,gBACf,sEAAsE,IAAI,EAC9E;CACJ;CAEA,IAAI,SAAkB;EAClB,OAAO,KAAK,SAAS;CACzB;CAEA,IAAI,WAAoB;EACpB,OAAO,KAAK,SAAS;CACzB;CAEA,WAAmB;EACf,OAAO,KAAK;CAChB;AACJ;;;;;;;;;;;;;ACzEA,IAAA,UAAA,MACe,gBAGL,QAAuB,CAAC;sBAJjC,QAAQ,KAAK,CAAA,GAAA,OAAA;;;ACZd,SAAgB,yBAAyB,KAAsC;CAC3E,QAAQ,IAAI,MAAZ;EACI,KAAK,mBACD,OAAO,IAAI,2BACP,UAAU,IAAI,MAAM,YAAY,KAChC,IAAI,SACJ;GAAE,WAAW,IAAI;GAAW,OAAO,IAAI;EAAM,GAC7C,EAAE,OAAO,IAAI,MAAM,CACvB;EACJ,KAAK,sBACD,OAAO,IAAI,2BACP,sBACA,IAAI,SACJ,EAAE,cAAc,IAAI,aAAa,GACjC,EAAE,OAAO,IAAI,MAAM,CACvB;EACJ,KAAK,oBACD,OAAO,IAAI,cACP,UACA,EAAE,WAAW,IAAI,UAAU,GAC3B,EAAE,OAAO,IAAI,MAAM,CACvB;EACJ,KAAK,+BACD,OAAO,IAAI,cACP,oBACA;GACI,WAAW,IAAI;GACf,gBAAgB,IAAI;GACpB,MAAM,IAAI,KAAK,YAAY;EAC/B,GACA,EAAE,OAAO,IAAI,MAAM,CACvB;EACJ,KAAK,4BACD,OAAO,IAAI,cACP,iBACA;GACI,WAAW,IAAI;GACf,YAAY,IAAI;GAChB,sBAAsB,IAAI;EAC9B,GACA,EAAE,OAAO,IAAI,MAAM,CACvB;EACJ,KAAK,kBACD,OAAO,IAAI,gBAAgB,IAAI,SAAS,IAAI,OAAO,EAC/C,UAAU;GACN,WAAW,IAAI;GACf,QAAQ,IAAI;GACZ,eAAe,IAAI;EACvB,EACJ,CAAC;CACT;AACJ;;;;;;;;;;;;;;;;ACnBA,IAAA,QAAA,MACe,cAIL,QAAsC;CAC5C,gBAAyC;EACrC,OAAO,EAAE,MAAM,WAAW;CAC9B;AACJ;oBATC,QAAQ,KAAK,CAAA,GAAA,KAAA;;;ACvBd,SAAS,WAAc,OAAa;CAChC,OAAO,mBAAmB,uBAAO,IAAI,QAAgB,CAAC;AAC1D;AAEA,SAAS,mBAAsB,OAAU,MAA0B;CAO/D,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,iBAAiB,MAChE,OAAO;CAKX,IAAI,KAAK,IAAI,KAAK,GACd,OAAO;CAEX,KAAK,IAAI,KAAK;CAEd,IAAI,MAAM,QAAQ,KAAK,GAAG;EACtB,KAAK,MAAM,QAAQ,OACf,mBAAmB,MAAM,IAAI;EAGjC,OAAO,OAAO,OAAO,KAAK;CAC9B;CAEA,MAAM,cAAc;CAEpB,KAAK,MAAM,eAAe,QAAQ,QAAQ,WAAW,GACjD,mBAAmB,YAAY,cAAc,IAAI;CAGrD,OAAO,OAAO,OAAO,KAAK;AAC9B;AAEA,SAAS,cAAiB,OAA2B;CACjD,IAAI,OAAO,UAAU,YAAY,UAAU,MACvC,OAAO;CAGX,IAAI;CACJ,IAAI;EACA,WAAW,gBAAgB,KAAK;CACpC,SAAS,OAAO;EAIZ,MAAM,IAAI,4BACN,wDACI,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAE7D;CACJ;CAEA,OAAO,WAAW,QAAQ;AAC9B;;;AC/DA,SAAS,sBACL,iBACA,YAAoB,mBAChB;CACJ,gBAAgB,GAAG,UAAU,QAAQ,gBAAgB,IAAI;CACzD,gBAAgB,GAAG,UAAU,eAAe,gBAAgB,WAAW;AAC3E;AAEA,SAAS,sBACL,QAAoC,CAAC,GACtB;CACf,MAAM,cAAc,MAAM,+BAAe,IAAI,KAAK;CAClD,MAAM,OAAO,MAAM,QAAQ;CAE3B,sBAAsB;EAAE;EAAM;CAAY,CAAC;CAE3C,OAAO,cAAc;EACjB;EACA;CACJ,CAAC;AACL;;;ACNA,IAAe,kBAAf,cAGU,QAA8C;CACpD,uBACI,OACe;EACf,OAAO,sBAAsB,MAAM,eAAe;CACtD;CAEA,gBACI,MACA,iBAC8B;EAC9B,OAAO,OAAO,OAAO;GACjB,GAAG;GACH,QAAQ;IACJ,GAAG,KAAK;IACR,KAAK,IAAI,KAAK,gBAAgB,YAAY,QAAQ,CAAC;GACvD;EACJ,CAAC;CACL;AACJ"}