@entifix/core 0.1.0-0

package/dist/envelope/read-envelope.js

@@ -0,0 +1,138 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { Effect } from 'effect';
+import { EntifixBuildError } from '../base-entities/entifix-error/index.js';
+import { deserializeEntityCollection, deserializeSingleEntity } from '../entity-definition/serializer/index.js';
+import { envelopeEntityName } from './make-envelope.js';
+/**
+ * Structural check only — `meta.type` is validated separately so a mismatch
+ * reports the expected/actual types rather than a generic "not an envelope".
+ */ export function isEntifixEnvelope(body) {
+    if (body == null || typeof body !== 'object') {
+        return false;
+    }
+    const meta = body.meta;
+    return meta != null && typeof meta === 'object' && typeof meta.type === 'string';
+}
+/**
+ * Narrows an arbitrary body to an envelope of the expected `meta.type`, failing
+ * with an {@link EntifixBuildError} otherwise. A wrong shape must never
+ * silently deserialize into a half-populated entity.
+ */ function assertEnvelope(entityConstructor, body, expected) {
+    const entity = envelopeEntityName(entityConstructor);
+    if (!isEntifixEnvelope(body)) {
+        return Effect.fail(new EntifixBuildError(`Expected an EntifixEnvelope for "${entity}" but the payload carried no meta.type`, undefined, {
+            entity,
+            expected,
+            body
+        }));
+    }
+    if (body.meta.type !== expected) {
+        return Effect.fail(new EntifixBuildError(`Expected an EntifixEnvelope of type "${expected}" for "${entity}" but got "${body.meta.type}"`, undefined, {
+            entity,
+            expected,
+            actual: body.meta.type
+        }));
+    }
+    return Effect.succeed(body);
+}
+/**
+ * Narrows an arbitrary body to an envelope of the expected `meta.type` without
+ * requiring an entity constructor — for `command`/`transactionRecord` messages
+ * whose `data` is not a serialized entity. `label` only sharpens error text.
+ */ export function readEnvelope(body, expected, label = 'message') {
+    if (!isEntifixEnvelope(body)) {
+        return Effect.fail(new EntifixBuildError(`Expected an EntifixEnvelope for "${label}" but the payload carried no meta.type`, undefined, {
+            label,
+            expected,
+            body
+        }));
+    }
+    if (body.meta.type !== expected) {
+        return Effect.fail(new EntifixBuildError(`Expected an EntifixEnvelope of type "${expected}" for "${label}" but got "${body.meta.type}"`, undefined, {
+            label,
+            expected,
+            actual: body.meta.type
+        }));
+    }
+    return Effect.succeed(body);
+}
+export const readEntityEnvelope = (entityConstructor, body)=>Effect.gen(function*() {
+        const envelope = yield* assertEnvelope(entityConstructor, body, 'entity');
+        const entity = yield* deserializeSingleEntity(entityConstructor, envelope.data);
+        if (entity === undefined) {
+            return yield* Effect.fail(new EntifixBuildError(`EntifixEnvelope for "${envelopeEntityName(entityConstructor)}" carried no data`, undefined, {
+                entity: envelopeEntityName(entityConstructor)
+            }));
+        }
+        return entity;
+    });
+export const readEntityCollectionEnvelope = (entityConstructor, body)=>Effect.gen(function*() {
+        const envelope = yield* assertEnvelope(entityConstructor, body, 'entityCollection');
+        const items = yield* deserializeEntityCollection(entityConstructor, envelope.data);
+        return items;
+    });
+export const readEntityPageEnvelope = (entityConstructor, body)=>Effect.gen(function*() {
+        var _ref, _ref1;
+        var _envelope_data, _envelope_data1, _envelope_data2;
+        const envelope = yield* assertEnvelope(entityConstructor, body, 'entityPage');
+        const items = yield* deserializeEntityCollection(entityConstructor, (_envelope_data = envelope.data) == null ? void 0 : _envelope_data.items);
+        return {
+            items: items,
+            total: (_ref = (_envelope_data1 = envelope.data) == null ? void 0 : _envelope_data1.total) != null ? _ref : 0,
+            request: (_ref1 = (_envelope_data2 = envelope.data) == null ? void 0 : _envelope_data2.request) != null ? _ref1 : {}
+        };
+    });
+/**
+ * Reads a `$metadata` response back into its document.
+ *
+ * No deserialization step, and no defaulting of the members either: an envelope
+ * whose `data` is missing a list would leave a form guessing whether "no
+ * actions" meant "denied" or "malformed", so a broken payload fails loudly here
+ * the way a half-populated entity does.
+ */ export const readEntityMetadataEnvelope = (entityConstructor, body)=>Effect.gen(function*() {
+        const envelope = yield* assertEnvelope(entityConstructor, body, 'entityMetadata');
+        const document = envelope.data;
+        if (!Array.isArray(document == null ? void 0 : document.actions) || !Array.isArray(document == null ? void 0 : document.useCases)) {
+            return yield* Effect.fail(new EntifixBuildError(`EntifixEnvelope for "${envelopeEntityName(entityConstructor)}" carried no metadata document`, undefined, {
+                entity: envelopeEntityName(entityConstructor)
+            }));
+        }
+        return document;
+    });
+/** Every member `meta.event` must carry for a message to be routable at all. */ const REQUIRED_EVENT_META = [
+    'name',
+    'id',
+    'source',
+    'at'
+];
+/**
+ * Reads a bus message back into a {@link DomainEvent}.
+ *
+ * The metadata is validated rather than defaulted, and that is the point: a
+ * message missing `id` cannot be deduplicated and a message missing `name`
+ * cannot be routed, so both are failures a consumer must see rather than
+ * absences it silently works around. It is the same call
+ * {@link readEntityMetadataEnvelope} makes — a broken payload fails loudly
+ * instead of arriving half-populated.
+ *
+ * Note this does not validate `data`. The transport has no idea what a
+ * `catalog.published` payload should look like, and inventing an opinion here
+ * is how the bus would start knowing about domains.
+ */ export function readEventEnvelope(body) {
+    return Effect.gen(function*() {
+        const envelope = yield* readEnvelope(body, 'event', 'event');
+        const event = envelope.meta.event;
+        const missing = REQUIRED_EVENT_META.filter((member)=>typeof (event == null ? void 0 : event[member]) !== 'string' || event[member] === '');
+        if (missing.length > 0) {
+            return yield* Effect.fail(new EntifixBuildError(`event envelope carried incomplete meta.event (missing ${missing.join(', ')})`, undefined, {
+                missing,
+                body
+            }));
+        }
+        return _extends({}, event, {
+            data: envelope.data
+        });
+    });
+}
+
+//# sourceMappingURL=read-envelope.js.map

package/dist/envelope/read-envelope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/envelope/read-envelope.ts"],"sourcesContent":["import { Effect } from 'effect';\n\nimport { EntifixBuildError } from '../base-entities/entifix-error/index.js';\nimport type { EntityMetadataDocument } from '../entity-definition/metadata/index.js';\nimport {\n  deserializeEntityCollection,\n  deserializeSingleEntity,\n} from '../entity-definition/serializer/index.js';\nimport type { Entity, EntityConstructor } from '../types/Entity.js';\nimport type { EntityPage } from '../types/EntityPage.js';\nimport { envelopeEntityName } from './make-envelope.js';\nimport type {\n  DomainEvent,\n  EntifixEnvelope,\n  EntifixEnvelopeType,\n  EntifixEventMeta,\n  SerializedEntityPage,\n} from './types.js';\n\n/**\n * Structural check only — `meta.type` is validated separately so a mismatch\n * reports the expected/actual types rather than a generic \"not an envelope\".\n */\nexport function isEntifixEnvelope(body: unknown): body is EntifixEnvelope {\n  if (body == null || typeof body !== 'object') {\n    return false;\n  }\n  const meta = (body as EntifixEnvelope).meta;\n  return (\n    meta != null && typeof meta === 'object' && typeof meta.type === 'string'\n  );\n}\n\n/**\n * Narrows an arbitrary body to an envelope of the expected `meta.type`, failing\n * with an {@link EntifixBuildError} otherwise. A wrong shape must never\n * silently deserialize into a half-populated entity.\n */\nfunction assertEnvelope<TEntity extends Entity, TData>(\n  entityConstructor: EntityConstructor<TEntity>,\n  body: unknown,\n  expected: EntifixEnvelopeType,\n): Effect.Effect<EntifixEnvelope<TData>, EntifixBuildError> {\n  const entity = envelopeEntityName(entityConstructor);\n\n  if (!isEntifixEnvelope(body)) {\n    return Effect.fail(\n      new EntifixBuildError(\n        `Expected an EntifixEnvelope for \"${entity}\" but the payload carried no meta.type`,\n        undefined,\n        { entity, expected, body },\n      ),\n    );\n  }\n  if (body.meta.type !== expected) {\n    return Effect.fail(\n      new EntifixBuildError(\n        `Expected an EntifixEnvelope of type \"${expected}\" for \"${entity}\" but got \"${body.meta.type}\"`,\n        undefined,\n        { entity, expected, actual: body.meta.type },\n      ),\n    );\n  }\n  return Effect.succeed(body as EntifixEnvelope<TData>);\n}\n\n/**\n * Narrows an arbitrary body to an envelope of the expected `meta.type` without\n * requiring an entity constructor — for `command`/`transactionRecord` messages\n * whose `data` is not a serialized entity. `label` only sharpens error text.\n */\nexport function readEnvelope<TData>(\n  body: unknown,\n  expected: EntifixEnvelopeType,\n  label = 'message',\n): Effect.Effect<EntifixEnvelope<TData>, EntifixBuildError> {\n  if (!isEntifixEnvelope(body)) {\n    return Effect.fail(\n      new EntifixBuildError(\n        `Expected an EntifixEnvelope for \"${label}\" but the payload carried no meta.type`,\n        undefined,\n        { label, expected, body },\n      ),\n    );\n  }\n  if (body.meta.type !== expected) {\n    return Effect.fail(\n      new EntifixBuildError(\n        `Expected an EntifixEnvelope of type \"${expected}\" for \"${label}\" but got \"${body.meta.type}\"`,\n        undefined,\n        { label, expected, actual: body.meta.type },\n      ),\n    );\n  }\n  return Effect.succeed(body as EntifixEnvelope<TData>);\n}\n\nexport const readEntityEnvelope = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  body: unknown,\n) =>\n  Effect.gen(function* () {\n    const envelope = yield* assertEnvelope<TEntity, unknown>(\n      entityConstructor,\n      body,\n      'entity',\n    );\n    const entity = yield* deserializeSingleEntity(\n      entityConstructor,\n      envelope.data,\n    );\n    if (entity === undefined) {\n      return yield* Effect.fail(\n        new EntifixBuildError(\n          `EntifixEnvelope for \"${envelopeEntityName(\n            entityConstructor,\n          )}\" carried no data`,\n          undefined,\n          { entity: envelopeEntityName(entityConstructor) },\n        ),\n      );\n    }\n    return entity;\n  });\n\nexport const readEntityCollectionEnvelope = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  body: unknown,\n) =>\n  Effect.gen(function* () {\n    const envelope = yield* assertEnvelope<TEntity, unknown>(\n      entityConstructor,\n      body,\n      'entityCollection',\n    );\n    const items = yield* deserializeEntityCollection(\n      entityConstructor,\n      envelope.data,\n    );\n    return items as TEntity[];\n  });\n\nexport const readEntityPageEnvelope = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  body: unknown,\n) =>\n  Effect.gen(function* () {\n    const envelope = yield* assertEnvelope<\n      TEntity,\n      SerializedEntityPage<TEntity>\n    >(entityConstructor, body, 'entityPage');\n    const items = yield* deserializeEntityCollection(\n      entityConstructor,\n      envelope.data?.items,\n    );\n    return {\n      items: items as TEntity[],\n      total: envelope.data?.total ?? 0,\n      request: envelope.data?.request ?? {},\n    } satisfies EntityPage<TEntity>;\n  });\n\n/**\n * Reads a `$metadata` response back into its document.\n *\n * No deserialization step, and no defaulting of the members either: an envelope\n * whose `data` is missing a list would leave a form guessing whether \"no\n * actions\" meant \"denied\" or \"malformed\", so a broken payload fails loudly here\n * the way a half-populated entity does.\n */\nexport const readEntityMetadataEnvelope = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  body: unknown,\n) =>\n  Effect.gen(function* () {\n    const envelope = yield* assertEnvelope<TEntity, EntityMetadataDocument>(\n      entityConstructor,\n      body,\n      'entityMetadata',\n    );\n    const document = envelope.data;\n    if (\n      !Array.isArray(document?.actions) ||\n      !Array.isArray(document?.useCases)\n    ) {\n      return yield* Effect.fail(\n        new EntifixBuildError(\n          `EntifixEnvelope for \"${envelopeEntityName(\n            entityConstructor,\n          )}\" carried no metadata document`,\n          undefined,\n          { entity: envelopeEntityName(entityConstructor) },\n        ),\n      );\n    }\n    return document;\n  });\n\n/** Every member `meta.event` must carry for a message to be routable at all. */\nconst REQUIRED_EVENT_META = ['name', 'id', 'source', 'at'] as const;\n\n/**\n * Reads a bus message back into a {@link DomainEvent}.\n *\n * The metadata is validated rather than defaulted, and that is the point: a\n * message missing `id` cannot be deduplicated and a message missing `name`\n * cannot be routed, so both are failures a consumer must see rather than\n * absences it silently works around. It is the same call\n * {@link readEntityMetadataEnvelope} makes — a broken payload fails loudly\n * instead of arriving half-populated.\n *\n * Note this does not validate `data`. The transport has no idea what a\n * `catalog.published` payload should look like, and inventing an opinion here\n * is how the bus would start knowing about domains.\n */\nexport function readEventEnvelope<TData = unknown>(\n  body: unknown,\n): Effect.Effect<DomainEvent<TData>, EntifixBuildError> {\n  return Effect.gen(function* () {\n    const envelope = yield* readEnvelope<TData>(body, 'event', 'event');\n    const event = envelope.meta.event;\n    const missing = REQUIRED_EVENT_META.filter(\n      member => typeof event?.[member] !== 'string' || event[member] === '',\n    );\n    if (missing.length > 0) {\n      return yield* Effect.fail(\n        new EntifixBuildError(\n          `event envelope carried incomplete meta.event (missing ${missing.join(\n            ', ',\n          )})`,\n          undefined,\n          { missing, body },\n        ),\n      );\n    }\n    return { ...(event as EntifixEventMeta), data: envelope.data };\n  });\n}\n"],"names":["Effect","EntifixBuildError","deserializeEntityCollection","deserializeSingleEntity","envelopeEntityName","isEntifixEnvelope","body","meta","type","assertEnvelope","entityConstructor","expected","entity","fail","undefined","actual","succeed","readEnvelope","label","readEntityEnvelope","gen","envelope","data","readEntityCollectionEnvelope","items","readEntityPageEnvelope","total","request","readEntityMetadataEnvelope","document","Array","isArray","actions","useCases","REQUIRED_EVENT_META","readEventEnvelope","event","missing","filter","member","length","join"],"mappings":"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"}

package/dist/envelope/types.d.ts

@@ -0,0 +1,173 @@
+import type { EntityMetadataDocument } from '../entity-definition/metadata/index.js';
+import type { SerializedEntity } from '../entity-definition/serializer/index.js';
+import type { Entity, EntityId } from '../types/Entity.js';
+import type { EntityLoadRequest } from '../types/EntityLoadRequest.js';
+/**
+ * Discriminates what {@link EntifixEnvelope.data} carries.
+ *
+ * `command` extends the contract for the transactions layer: a write is issued
+ * as a `command`, whose `data` shape lives in `@entifix/transactions` —
+ * core only owns the discriminant so every artifact agrees on it.
+ *
+ * `event` is what actually rides the bus, and it is deliberately not named
+ * after one publisher's flow: once a message can be `catalog.published` as
+ * easily as `transaction.completed`, `transactionEvent` would be the wrong
+ * name for it.
+ *
+ * ⚠️ **The four transaction-shaped discriminants below are four because they
+ * carry four shapes.** `transactionEvent` used to mean all of them, and a
+ * discriminant that means several things asserts nothing when it is read —
+ * which is what `readTransactionEventEnvelope` was doing on the `202`: checking
+ * a name that the record route and the event type both also answered to
+ * ([ADR 0055](../../../../../../docs/adr/0055-a-coordinator-resumes-from-its-own-record.md),
+ * #176).
+ *
+ * - `transactionAccepted` — the `202` accept body, `{ transactionId, state }`.
+ *   Not a record: it has no `createdAt` and names no entity id yet.
+ * - `transactionRecord` — the fold a client polls, a `TransactionRecord`.
+ * - `sagaResult` — how a settled multi-step walk ended: which steps ran and
+ *   what each returned ([ADR 0052](../../../../../../docs/adr/0052-the-checkout-saga.md)).
+ * - `sagaInstance` — the durable instance itself, which is what a resumable
+ *   coordinator reads and what `GET /api/saga/:id` serves. It differs from
+ *   `sagaResult` in carrying the inputs and the resume count, because those are
+ *   what an operator needs to answer *why is this one still here*.
+ *
+ * `entityMetadata` is the same extension made once more, for the action model:
+ * its `data` is an {@link EntityMetadataDocument}, which core does own because
+ * both the service that computes it and the controls that render it are already
+ * below the layer that would otherwise host it.
+ */
+export type EntifixEnvelopeType = 'entity' | 'entityCollection' | 'entityPage' | 'command' | 'event' | 'transactionAccepted' | 'transactionRecord' | 'sagaResult' | 'sagaInstance' | 'entityMetadata';
+export type EntifixEnvelopeMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+/**
+ * A HATEOAS affordance: where the peer can go next from this message. Optional —
+ * the envelope stands on its own without links, and only the artifact that owns
+ * a route surface (today the REST service) is able to fill them in.
+ */
+export interface EntifixEnvelopeLink {
+    rel: string;
+    href: string;
+    method?: EntifixEnvelopeMethod;
+}
+/**
+ * The facts a message carries about *itself*, as opposed to about what
+ * happened. Present only when the envelope is a bus message.
+ *
+ * The split rule: `meta` describes the message, `data` describes the
+ * occurrence. So `correlationId` belongs here and an outcome's `code` does not.
+ *
+ * **`source` is never a consumer branch.** It is there for routing,
+ * observability and audit. A handler that behaves differently depending on who
+ * published re-couples the two services the bus decoupled — which is why .NET's
+ * canonical `(sender, eventArgs)` types its sender as bare `object`, making the
+ * dependency awkward on purpose. TypeScript cannot reproduce that friction, so
+ * here it is a rule rather than a type.
+ */
+export interface EntifixEventMeta {
+    /**
+     * What happened, in the register's vocabulary: `catalog.published`,
+     * `transaction.completed`. Declared in `tools/slices/*.slice.ts` as
+     * `publishedEvents`/`subscriptions`, and used verbatim as the AMQP routing
+     * key — which is what makes a subscriber's declared interest and its actual
+     * queue binding the same string.
+     */
+    name: string;
+    /**
+     * Unique per message, and **the** deduplication key. Delivery is
+     * at-least-once, so a consumer that must not fold twice keys on this.
+     *
+     * Not `correlationId`: one flow emits several messages, so correlating and
+     * deduplicating are different questions. Keying dedup on the correlation id
+     * makes a transaction's `completed` look like a duplicate of its `accepted`.
+     */
+    id: string;
+    /** The emitting **slice** (ADR 0020's ownership noun), e.g. `marketplace-admin`. */
+    source: string;
+    /** ISO-8601 emission time. */
+    at: string;
+    /** Ties every message of one flow together — a transaction id, a saga id. */
+    correlationId?: string;
+}
+export interface EntifixEnvelopeMeta {
+    type: EntifixEnvelopeType;
+    /**
+     * The target entity's `key` (falling back to its class name).
+     *
+     * Optional, because a bus message need not be about an entity at all —
+     * `settlement.run.completed` is about a run. What a message *is* lives in
+     * {@link EntifixEventMeta.name}; this stays the entity label the HTTP arm
+     * routes on.
+     */
+    entity?: string;
+    links?: EntifixEnvelopeLink[];
+    /** Present only on a bus message. */
+    event?: EntifixEventMeta;
+}
+/**
+ * One message on the bus: its own metadata, plus the payload describing what
+ * happened.
+ *
+ * Generic in the payload so a publisher keeps its own shape —
+ * `DomainEvent<TransactionEvent>` today, `DomainEvent<PublishedOffering>` when
+ * ADR 0009's projection event lands — without the transport learning either.
+ */
+export interface DomainEvent<TData = unknown> extends EntifixEventMeta {
+    data: TData;
+}
+/**
+ * A change to an entity that happened on the server, delivered out-of-band —
+ * the `data` of a bus/stream `event` envelope rather than a framing of its own
+ * (ADR 0036). `entity` is the `key ?? name` an adapter routes on, the same
+ * string `entityQueryScope` uses, so a subscriber can invalidate exactly the
+ * affected query keys.
+ *
+ * It lives in core rather than beside the React `ReactiveChannel` that consumes
+ * it because both ends need it: the service maps a `TransactionEvent` onto it,
+ * and `entifix:react` sits above every layer that does the mapping.
+ *
+ * Deliberately **no** `transactionId`, timestamp or sequence: all three already
+ * exist one level up as `meta.event.correlationId`, `.at` and `.id`, and
+ * duplicating them onto the payload is how two sources of the same fact drift.
+ */
+export interface EntityChangeEvent {
+    entity: string;
+    change: 'created' | 'updated' | 'deleted';
+    id: EntityId;
+}
+/**
+ * The standard message exchanged between entifix artifacts.
+ *
+ * Every request and response body is an envelope: `meta` describes the payload,
+ * `data` is the payload. It is deliberately transport-free — it lives in `core`
+ * and knows nothing about HTTP — so the same contract can carry entities over
+ * REST today and amqp or websockets later.
+ */
+export interface EntifixEnvelope<TData = unknown> {
+    meta: EntifixEnvelopeMeta;
+    data: TData;
+}
+/**
+ * `data` shape when `meta.type` is `entityPage`. Generic in the entity so the
+ * echoed `request` keeps its `keyof TEntity` filter/sort types — `EntityLoadRequest`
+ * is invariant in its entity, so a non-generic `EntityLoadRequest<Entity>` here
+ * would not accept a caller's `EntityLoadRequest<Product>`.
+ */
+export interface SerializedEntityPage<TEntity extends Entity = Entity> {
+    items: SerializedEntity[];
+    total: number;
+    request?: EntityLoadRequest<TEntity>;
+}
+export type EntityEnvelope = EntifixEnvelope<SerializedEntity>;
+export type EntityCollectionEnvelope = EntifixEnvelope<SerializedEntity[]>;
+export type EntityPageEnvelope<TEntity extends Entity = Entity> = EntifixEnvelope<SerializedEntityPage<TEntity>>;
+export type EntityMetadataEnvelope = EntifixEnvelope<EntityMetadataDocument>;
+/**
+ * A bus message on the wire. `meta.event` is always populated, and
+ * `readEventEnvelope` is what proves it before a consumer sees the payload.
+ */
+export type EventEnvelope<TData = unknown> = EntifixEnvelope<TData> & {
+    meta: EntifixEnvelopeMeta & {
+        event: EntifixEventMeta;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/envelope/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/envelope/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,mBAAmB,GAC3B,QAAQ,GACR,kBAAkB,GAClB,YAAY,GACZ,SAAS,GACT,OAAO,GACP,qBAAqB,GACrB,mBAAmB,GACnB,YAAY,GACZ,cAAc,GACd,gBAAgB,CAAC;AAErB,MAAM,MAAM,qBAAqB,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,qBAAqB,CAAC;CAChC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,mBAAmB,CAAC;IAC1B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC9B,qCAAqC;IACrC,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW,CAAC,KAAK,GAAG,OAAO,CAAE,SAAQ,gBAAgB;IACpE,IAAI,EAAE,KAAK,CAAC;CACb;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAC1C,EAAE,EAAE,QAAQ,CAAC;CACd;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe,CAAC,KAAK,GAAG,OAAO;IAC9C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,EAAE,KAAK,CAAC;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM;IACnE,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,wBAAwB,GAAG,eAAe,CAAC,gBAAgB,EAAE,CAAC,CAAC;AAC3E,MAAM,MAAM,kBAAkB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,IAC5D,eAAe,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;AACjD,MAAM,MAAM,sBAAsB,GAAG,eAAe,CAAC,sBAAsB,CAAC,CAAC;AAE7E;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,KAAK,GAAG,OAAO,IAAI,eAAe,CAAC,KAAK,CAAC,GAAG;IACpE,IAAI,EAAE,mBAAmB,GAAG;QAAE,KAAK,EAAE,gBAAgB,CAAA;KAAE,CAAC;CACzD,CAAC"}

package/dist/envelope/types.js

@@ -0,0 +1,6 @@
+/**
+ * A bus message on the wire. `meta.event` is always populated, and
+ * `readEventEnvelope` is what proves it before a consumer sees the payload.
+ */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/envelope/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/envelope/types.ts"],"sourcesContent":["import type { EntityMetadataDocument } from '../entity-definition/metadata/index.js';\nimport type { SerializedEntity } from '../entity-definition/serializer/index.js';\nimport type { Entity, EntityId } from '../types/Entity.js';\nimport type { EntityLoadRequest } from '../types/EntityLoadRequest.js';\n\n/**\n * Discriminates what {@link EntifixEnvelope.data} carries.\n *\n * `command` extends the contract for the transactions layer: a write is issued\n * as a `command`, whose `data` shape lives in `@entifix/transactions` —\n * core only owns the discriminant so every artifact agrees on it.\n *\n * `event` is what actually rides the bus, and it is deliberately not named\n * after one publisher's flow: once a message can be `catalog.published` as\n * easily as `transaction.completed`, `transactionEvent` would be the wrong\n * name for it.\n *\n * ⚠️ **The four transaction-shaped discriminants below are four because they\n * carry four shapes.** `transactionEvent` used to mean all of them, and a\n * discriminant that means several things asserts nothing when it is read —\n * which is what `readTransactionEventEnvelope` was doing on the `202`: checking\n * a name that the record route and the event type both also answered to\n * ([ADR 0055](../../../../../../docs/adr/0055-a-coordinator-resumes-from-its-own-record.md),\n * #176).\n *\n * - `transactionAccepted` — the `202` accept body, `{ transactionId, state }`.\n *   Not a record: it has no `createdAt` and names no entity id yet.\n * - `transactionRecord` — the fold a client polls, a `TransactionRecord`.\n * - `sagaResult` — how a settled multi-step walk ended: which steps ran and\n *   what each returned ([ADR 0052](../../../../../../docs/adr/0052-the-checkout-saga.md)).\n * - `sagaInstance` — the durable instance itself, which is what a resumable\n *   coordinator reads and what `GET /api/saga/:id` serves. It differs from\n *   `sagaResult` in carrying the inputs and the resume count, because those are\n *   what an operator needs to answer *why is this one still here*.\n *\n * `entityMetadata` is the same extension made once more, for the action model:\n * its `data` is an {@link EntityMetadataDocument}, which core does own because\n * both the service that computes it and the controls that render it are already\n * below the layer that would otherwise host it.\n */\nexport type EntifixEnvelopeType =\n  | 'entity'\n  | 'entityCollection'\n  | 'entityPage'\n  | 'command'\n  | 'event'\n  | 'transactionAccepted'\n  | 'transactionRecord'\n  | 'sagaResult'\n  | 'sagaInstance'\n  | 'entityMetadata';\n\nexport type EntifixEnvelopeMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';\n\n/**\n * A HATEOAS affordance: where the peer can go next from this message. Optional —\n * the envelope stands on its own without links, and only the artifact that owns\n * a route surface (today the REST service) is able to fill them in.\n */\nexport interface EntifixEnvelopeLink {\n  rel: string;\n  href: string;\n  method?: EntifixEnvelopeMethod;\n}\n\n/**\n * The facts a message carries about *itself*, as opposed to about what\n * happened. Present only when the envelope is a bus message.\n *\n * The split rule: `meta` describes the message, `data` describes the\n * occurrence. So `correlationId` belongs here and an outcome's `code` does not.\n *\n * **`source` is never a consumer branch.** It is there for routing,\n * observability and audit. A handler that behaves differently depending on who\n * published re-couples the two services the bus decoupled — which is why .NET's\n * canonical `(sender, eventArgs)` types its sender as bare `object`, making the\n * dependency awkward on purpose. TypeScript cannot reproduce that friction, so\n * here it is a rule rather than a type.\n */\nexport interface EntifixEventMeta {\n  /**\n   * What happened, in the register's vocabulary: `catalog.published`,\n   * `transaction.completed`. Declared in `tools/slices/*.slice.ts` as\n   * `publishedEvents`/`subscriptions`, and used verbatim as the AMQP routing\n   * key — which is what makes a subscriber's declared interest and its actual\n   * queue binding the same string.\n   */\n  name: string;\n  /**\n   * Unique per message, and **the** deduplication key. Delivery is\n   * at-least-once, so a consumer that must not fold twice keys on this.\n   *\n   * Not `correlationId`: one flow emits several messages, so correlating and\n   * deduplicating are different questions. Keying dedup on the correlation id\n   * makes a transaction's `completed` look like a duplicate of its `accepted`.\n   */\n  id: string;\n  /** The emitting **slice** (ADR 0020's ownership noun), e.g. `marketplace-admin`. */\n  source: string;\n  /** ISO-8601 emission time. */\n  at: string;\n  /** Ties every message of one flow together — a transaction id, a saga id. */\n  correlationId?: string;\n}\n\nexport interface EntifixEnvelopeMeta {\n  type: EntifixEnvelopeType;\n  /**\n   * The target entity's `key` (falling back to its class name).\n   *\n   * Optional, because a bus message need not be about an entity at all —\n   * `settlement.run.completed` is about a run. What a message *is* lives in\n   * {@link EntifixEventMeta.name}; this stays the entity label the HTTP arm\n   * routes on.\n   */\n  entity?: string;\n  links?: EntifixEnvelopeLink[];\n  /** Present only on a bus message. */\n  event?: EntifixEventMeta;\n}\n\n/**\n * One message on the bus: its own metadata, plus the payload describing what\n * happened.\n *\n * Generic in the payload so a publisher keeps its own shape —\n * `DomainEvent<TransactionEvent>` today, `DomainEvent<PublishedOffering>` when\n * ADR 0009's projection event lands — without the transport learning either.\n */\nexport interface DomainEvent<TData = unknown> extends EntifixEventMeta {\n  data: TData;\n}\n\n/**\n * A change to an entity that happened on the server, delivered out-of-band —\n * the `data` of a bus/stream `event` envelope rather than a framing of its own\n * (ADR 0036). `entity` is the `key ?? name` an adapter routes on, the same\n * string `entityQueryScope` uses, so a subscriber can invalidate exactly the\n * affected query keys.\n *\n * It lives in core rather than beside the React `ReactiveChannel` that consumes\n * it because both ends need it: the service maps a `TransactionEvent` onto it,\n * and `entifix:react` sits above every layer that does the mapping.\n *\n * Deliberately **no** `transactionId`, timestamp or sequence: all three already\n * exist one level up as `meta.event.correlationId`, `.at` and `.id`, and\n * duplicating them onto the payload is how two sources of the same fact drift.\n */\nexport interface EntityChangeEvent {\n  entity: string;\n  change: 'created' | 'updated' | 'deleted';\n  id: EntityId;\n}\n\n/**\n * The standard message exchanged between entifix artifacts.\n *\n * Every request and response body is an envelope: `meta` describes the payload,\n * `data` is the payload. It is deliberately transport-free — it lives in `core`\n * and knows nothing about HTTP — so the same contract can carry entities over\n * REST today and amqp or websockets later.\n */\nexport interface EntifixEnvelope<TData = unknown> {\n  meta: EntifixEnvelopeMeta;\n  data: TData;\n}\n\n/**\n * `data` shape when `meta.type` is `entityPage`. Generic in the entity so the\n * echoed `request` keeps its `keyof TEntity` filter/sort types — `EntityLoadRequest`\n * is invariant in its entity, so a non-generic `EntityLoadRequest<Entity>` here\n * would not accept a caller's `EntityLoadRequest<Product>`.\n */\nexport interface SerializedEntityPage<TEntity extends Entity = Entity> {\n  items: SerializedEntity[];\n  total: number;\n  request?: EntityLoadRequest<TEntity>;\n}\n\nexport type EntityEnvelope = EntifixEnvelope<SerializedEntity>;\nexport type EntityCollectionEnvelope = EntifixEnvelope<SerializedEntity[]>;\nexport type EntityPageEnvelope<TEntity extends Entity = Entity> =\n  EntifixEnvelope<SerializedEntityPage<TEntity>>;\nexport type EntityMetadataEnvelope = EntifixEnvelope<EntityMetadataDocument>;\n\n/**\n * A bus message on the wire. `meta.event` is always populated, and\n * `readEventEnvelope` is what proves it before a consumer sees the payload.\n */\nexport type EventEnvelope<TData = unknown> = EntifixEnvelope<TData> & {\n  meta: EntifixEnvelopeMeta & { event: EntifixEventMeta };\n};\n"],"names":[],"mappings":"AAyLA;;;CAGC,GACD,WAEE"}

package/dist/http/session-cookies.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The names of the cookies an entifix application's session travels in.
+ *
+ * ⚠️ **Constants in one place, deliberately not a runtime option.** Three
+ * packages read or write these — the Effect service shell verifies the access
+ * token, the Next shell sets and clears all three, and the Playwright helpers
+ * seed them — and a Next application runs its middleware, its server and its
+ * client as separate bundles, each with its own module state. A prefix a host
+ * configured in one bundle would never reach the others: the middleware would
+ * look for one name while a route wrote another, and the only symptom is being
+ * signed out. So the names are fixed and shared, and every reader imports them
+ * from here instead of re-declaring a literal — which is how r10c had five
+ * separate copies of `r10c_at` that nothing kept in step
+ * ([ADR 0059](../../../../../../docs/adr/0059-entifix-leaves-the-repo.md)).
+ *
+ * Host-scoped in dev, where localhost shares cookies across ports, so every app
+ * and service in a local fleet reads the same session.
+ */
+/** Short-lived signed access token the services verify. httpOnly. */
+export declare const ACCESS_COOKIE = "entifix_at";
+/** Opaque session id — the revocation handle and the refresh source. httpOnly. */
+export declare const SESSION_COOKIE = "entifix_sid";
+/** Long-lived, opaque device id. Cleared with cookies — that is intended. */
+export declare const DEVICE_COOKIE = "entifix_did";
+//# sourceMappingURL=session-cookies.d.ts.map

package/dist/http/session-cookies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-cookies.d.ts","sourceRoot":"","sources":["../../src/http/session-cookies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,qEAAqE;AACrE,eAAO,MAAM,aAAa,eAAe,CAAC;AAE1C,kFAAkF;AAClF,eAAO,MAAM,cAAc,gBAAgB,CAAC;AAE5C,6EAA6E;AAC7E,eAAO,MAAM,aAAa,gBAAgB,CAAC"}

package/dist/http/session-cookies.js

@@ -0,0 +1,22 @@
+/**
+ * The names of the cookies an entifix application's session travels in.
+ *
+ * ⚠️ **Constants in one place, deliberately not a runtime option.** Three
+ * packages read or write these — the Effect service shell verifies the access
+ * token, the Next shell sets and clears all three, and the Playwright helpers
+ * seed them — and a Next application runs its middleware, its server and its
+ * client as separate bundles, each with its own module state. A prefix a host
+ * configured in one bundle would never reach the others: the middleware would
+ * look for one name while a route wrote another, and the only symptom is being
+ * signed out. So the names are fixed and shared, and every reader imports them
+ * from here instead of re-declaring a literal — which is how r10c had five
+ * separate copies of `r10c_at` that nothing kept in step
+ * ([ADR 0059](../../../../../../docs/adr/0059-entifix-leaves-the-repo.md)).
+ *
+ * Host-scoped in dev, where localhost shares cookies across ports, so every app
+ * and service in a local fleet reads the same session.
+ */ /** Short-lived signed access token the services verify. httpOnly. */ export const ACCESS_COOKIE = 'entifix_at';
+/** Opaque session id — the revocation handle and the refresh source. httpOnly. */ export const SESSION_COOKIE = 'entifix_sid';
+/** Long-lived, opaque device id. Cleared with cookies — that is intended. */ export const DEVICE_COOKIE = 'entifix_did';
+
+//# sourceMappingURL=session-cookies.js.map

package/dist/http/session-cookies.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/http/session-cookies.ts"],"sourcesContent":["/**\n * The names of the cookies an entifix application's session travels in.\n *\n * ⚠️ **Constants in one place, deliberately not a runtime option.** Three\n * packages read or write these — the Effect service shell verifies the access\n * token, the Next shell sets and clears all three, and the Playwright helpers\n * seed them — and a Next application runs its middleware, its server and its\n * client as separate bundles, each with its own module state. A prefix a host\n * configured in one bundle would never reach the others: the middleware would\n * look for one name while a route wrote another, and the only symptom is being\n * signed out. So the names are fixed and shared, and every reader imports them\n * from here instead of re-declaring a literal — which is how r10c had five\n * separate copies of `r10c_at` that nothing kept in step\n * ([ADR 0059](../../../../../../docs/adr/0059-entifix-leaves-the-repo.md)).\n *\n * Host-scoped in dev, where localhost shares cookies across ports, so every app\n * and service in a local fleet reads the same session.\n */\n\n/** Short-lived signed access token the services verify. httpOnly. */\nexport const ACCESS_COOKIE = 'entifix_at';\n\n/** Opaque session id — the revocation handle and the refresh source. httpOnly. */\nexport const SESSION_COOKIE = 'entifix_sid';\n\n/** Long-lived, opaque device id. Cleared with cookies — that is intended. */\nexport const DEVICE_COOKIE = 'entifix_did';\n"],"names":["ACCESS_COOKIE","SESSION_COOKIE","DEVICE_COOKIE"],"mappings":"AAAA;;;;;;;;;;;;;;;;;CAiBC,GAED,mEAAmE,GACnE,OAAO,MAAMA,gBAAgB,aAAa;AAE1C,gFAAgF,GAChF,OAAO,MAAMC,iBAAiB,cAAc;AAE5C,2EAA2E,GAC3E,OAAO,MAAMC,gBAAgB,cAAc"}

package/dist/i18n/format.d.ts

@@ -0,0 +1,22 @@
+import type { Locale } from './locales.js';
+export interface Formatters {
+    /** Calendar date only. */
+    date(value: Date | string | number): string;
+    /** Date plus wall-clock time. */
+    dateTime(value: Date | string | number): string;
+    number(value: number, options?: Intl.NumberFormatOptions): string;
+    currency(value: number, currency: string): string;
+    relative(value: number, unit: Intl.RelativeTimeFormatUnit): string;
+}
+/**
+ * Locale-aware formatting, memoized per locale because constructing an `Intl.*`
+ * formatter is expensive and these run once per table cell.
+ *
+ * This exists to kill an argument-less `toLocaleString()`, which resolves against
+ * the *runtime's* default locale — Node's on the server, the visitor's in the
+ * browser. Those disagree, so the same cell rendered twice produced two strings
+ * and React reported a hydration mismatch. Passing the negotiated locale
+ * explicitly makes both halves agree by construction.
+ */
+export declare function makeFormatters(locale: Locale): Formatters;
+//# sourceMappingURL=format.d.ts.map

package/dist/i18n/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/i18n/format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,WAAW,UAAU;IACzB,0BAA0B;IAC1B,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAC5C,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAChD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,sBAAsB,GAAG,MAAM,CAAC;CACpE;AAUD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAoCzD"}

package/dist/i18n/format.js

@@ -0,0 +1,49 @@
+/** `undefined` for an unparseable input, so callers can fall back to the raw value. */ function toDate(value) {
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+const cache = new Map();
+/**
+ * Locale-aware formatting, memoized per locale because constructing an `Intl.*`
+ * formatter is expensive and these run once per table cell.
+ *
+ * This exists to kill an argument-less `toLocaleString()`, which resolves against
+ * the *runtime's* default locale — Node's on the server, the visitor's in the
+ * browser. Those disagree, so the same cell rendered twice produced two strings
+ * and React reported a hydration mismatch. Passing the negotiated locale
+ * explicitly makes both halves agree by construction.
+ */ export function makeFormatters(locale) {
+    const cached = cache.get(locale);
+    if (cached !== undefined) return cached;
+    const dateFormat = new Intl.DateTimeFormat(locale, {
+        dateStyle: 'medium'
+    });
+    const dateTimeFormat = new Intl.DateTimeFormat(locale, {
+        dateStyle: 'medium',
+        timeStyle: 'short'
+    });
+    const numberFormat = new Intl.NumberFormat(locale);
+    const relativeFormat = new Intl.RelativeTimeFormat(locale, {
+        numeric: 'auto'
+    });
+    const formatters = {
+        date: (value)=>{
+            const date = toDate(value);
+            return date === undefined ? String(value) : dateFormat.format(date);
+        },
+        dateTime: (value)=>{
+            const date = toDate(value);
+            return date === undefined ? String(value) : dateTimeFormat.format(date);
+        },
+        number: (value, options)=>options === undefined ? numberFormat.format(value) : new Intl.NumberFormat(locale, options).format(value),
+        currency: (value, currency)=>new Intl.NumberFormat(locale, {
+                style: 'currency',
+                currency
+            }).format(value),
+        relative: (value, unit)=>relativeFormat.format(value, unit)
+    };
+    cache.set(locale, formatters);
+    return formatters;
+}
+
+//# sourceMappingURL=format.js.map

package/dist/i18n/format.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/format.ts"],"sourcesContent":["import type { Locale } from './locales.js';\n\nexport interface Formatters {\n  /** Calendar date only. */\n  date(value: Date | string | number): string;\n  /** Date plus wall-clock time. */\n  dateTime(value: Date | string | number): string;\n  number(value: number, options?: Intl.NumberFormatOptions): string;\n  currency(value: number, currency: string): string;\n  relative(value: number, unit: Intl.RelativeTimeFormatUnit): string;\n}\n\n/** `undefined` for an unparseable input, so callers can fall back to the raw value. */\nfunction toDate(value: Date | string | number): Date | undefined {\n  const date = value instanceof Date ? value : new Date(value);\n  return Number.isNaN(date.getTime()) ? undefined : date;\n}\n\nconst cache = new Map<Locale, Formatters>();\n\n/**\n * Locale-aware formatting, memoized per locale because constructing an `Intl.*`\n * formatter is expensive and these run once per table cell.\n *\n * This exists to kill an argument-less `toLocaleString()`, which resolves against\n * the *runtime's* default locale — Node's on the server, the visitor's in the\n * browser. Those disagree, so the same cell rendered twice produced two strings\n * and React reported a hydration mismatch. Passing the negotiated locale\n * explicitly makes both halves agree by construction.\n */\nexport function makeFormatters(locale: Locale): Formatters {\n  const cached = cache.get(locale);\n  if (cached !== undefined) return cached;\n\n  const dateFormat = new Intl.DateTimeFormat(locale, { dateStyle: 'medium' });\n  const dateTimeFormat = new Intl.DateTimeFormat(locale, {\n    dateStyle: 'medium',\n    timeStyle: 'short',\n  });\n  const numberFormat = new Intl.NumberFormat(locale);\n  const relativeFormat = new Intl.RelativeTimeFormat(locale, {\n    numeric: 'auto',\n  });\n\n  const formatters: Formatters = {\n    date: value => {\n      const date = toDate(value);\n      return date === undefined ? String(value) : dateFormat.format(date);\n    },\n    dateTime: value => {\n      const date = toDate(value);\n      return date === undefined ? String(value) : dateTimeFormat.format(date);\n    },\n    number: (value, options) =>\n      options === undefined\n        ? numberFormat.format(value)\n        : new Intl.NumberFormat(locale, options).format(value),\n    currency: (value, currency) =>\n      new Intl.NumberFormat(locale, { style: 'currency', currency }).format(\n        value,\n      ),\n    relative: (value, unit) => relativeFormat.format(value, unit),\n  };\n\n  cache.set(locale, formatters);\n  return formatters;\n}\n"],"names":["toDate","value","date","Date","Number","isNaN","getTime","undefined","cache","Map","makeFormatters","locale","cached","get","dateFormat","Intl","DateTimeFormat","dateStyle","dateTimeFormat","timeStyle","numberFormat","NumberFormat","relativeFormat","RelativeTimeFormat","numeric","formatters","String","format","dateTime","number","options","currency","style","relative","unit","set"],"mappings":"AAYA,qFAAqF,GACrF,SAASA,OAAOC,KAA6B;IAC3C,MAAMC,OAAOD,iBAAiBE,OAAOF,QAAQ,IAAIE,KAAKF;IACtD,OAAOG,OAAOC,KAAK,CAACH,KAAKI,OAAO,MAAMC,YAAYL;AACpD;AAEA,MAAMM,QAAQ,IAAIC;AAElB;;;;;;;;;CASC,GACD,OAAO,SAASC,eAAeC,MAAc;IAC3C,MAAMC,SAASJ,MAAMK,GAAG,CAACF;IACzB,IAAIC,WAAWL,WAAW,OAAOK;IAEjC,MAAME,aAAa,IAAIC,KAAKC,cAAc,CAACL,QAAQ;QAAEM,WAAW;IAAS;IACzE,MAAMC,iBAAiB,IAAIH,KAAKC,cAAc,CAACL,QAAQ;QACrDM,WAAW;QACXE,WAAW;IACb;IACA,MAAMC,eAAe,IAAIL,KAAKM,YAAY,CAACV;IAC3C,MAAMW,iBAAiB,IAAIP,KAAKQ,kBAAkB,CAACZ,QAAQ;QACzDa,SAAS;IACX;IAEA,MAAMC,aAAyB;QAC7BvB,MAAMD,CAAAA;YACJ,MAAMC,OAAOF,OAAOC;YACpB,OAAOC,SAASK,YAAYmB,OAAOzB,SAASa,WAAWa,MAAM,CAACzB;QAChE;QACA0B,UAAU3B,CAAAA;YACR,MAAMC,OAAOF,OAAOC;YACpB,OAAOC,SAASK,YAAYmB,OAAOzB,SAASiB,eAAeS,MAAM,CAACzB;QACpE;QACA2B,QAAQ,CAAC5B,OAAO6B,UACdA,YAAYvB,YACRa,aAAaO,MAAM,CAAC1B,SACpB,IAAIc,KAAKM,YAAY,CAACV,QAAQmB,SAASH,MAAM,CAAC1B;QACpD8B,UAAU,CAAC9B,OAAO8B,WAChB,IAAIhB,KAAKM,YAAY,CAACV,QAAQ;gBAAEqB,OAAO;gBAAYD;YAAS,GAAGJ,MAAM,CACnE1B;QAEJgC,UAAU,CAAChC,OAAOiC,OAASZ,eAAeK,MAAM,CAAC1B,OAAOiC;IAC1D;IAEA1B,MAAM2B,GAAG,CAACxB,QAAQc;IAClB,OAAOA;AACT"}

package/dist/i18n/index.d.ts

@@ -0,0 +1,4 @@
+export * from './format.js';
+export * from './locales.js';
+export * from './negotiate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/dist/i18n/index.js

@@ -0,0 +1,5 @@
+export * from './format.js';
+export * from './locales.js';
+export * from './negotiate.js';
+
+//# sourceMappingURL=index.js.map

package/dist/i18n/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/index.ts"],"sourcesContent":["export * from './format.js';\nexport * from './locales.js';\nexport * from './negotiate.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc;AAC5B,cAAc,eAAe;AAC7B,cAAc,iBAAiB"}

package/dist/i18n/locales.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The locales the fleet ships. `es` is the default and the fallback: a key that
+ * is missing from a catalog resolves against Spanish rather than rendering the
+ * raw key, so a half-translated `en` degrades to readable text instead of
+ * `controls:table.actions`.
+ */
+export declare const LOCALES: readonly ["es", "en"];
+export type Locale = (typeof LOCALES)[number];
+export declare const DEFAULT_LOCALE: Locale;
+/**
+ * Host-scoped so the choice is shared across the fleet's localhost ports in dev,
+ * exactly like `entifix_at`/`entifix_sid`. Written by the locale middleware on every
+ * redirect, so a visitor who lands on `/en/...` keeps English on the next visit.
+ */
+export declare const LOCALE_COOKIE = "entifix_locale";
+/**
+ * Request header the locale middleware sets when it rewrites a prefixed path.
+ * Server components read it instead of a route param, which is what lets the
+ * route tree stay free of an `app/[locale]` segment.
+ */
+export declare const LOCALE_HEADER = "x-entifix-locale";
+export declare function isLocale(value: unknown): value is Locale;
+//# sourceMappingURL=locales.d.ts.map

package/dist/i18n/locales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../src/i18n/locales.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,OAAO,uBAAwB,CAAC;AAE7C,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9C,eAAO,MAAM,cAAc,EAAE,MAAa,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAEhD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAIxD"}

package/dist/i18n/locales.js

@@ -0,0 +1,25 @@
+/**
+ * The locales the fleet ships. `es` is the default and the fallback: a key that
+ * is missing from a catalog resolves against Spanish rather than rendering the
+ * raw key, so a half-translated `en` degrades to readable text instead of
+ * `controls:table.actions`.
+ */ export const LOCALES = [
+    'es',
+    'en'
+];
+export const DEFAULT_LOCALE = 'es';
+/**
+ * Host-scoped so the choice is shared across the fleet's localhost ports in dev,
+ * exactly like `entifix_at`/`entifix_sid`. Written by the locale middleware on every
+ * redirect, so a visitor who lands on `/en/...` keeps English on the next visit.
+ */ export const LOCALE_COOKIE = 'entifix_locale';
+/**
+ * Request header the locale middleware sets when it rewrites a prefixed path.
+ * Server components read it instead of a route param, which is what lets the
+ * route tree stay free of an `app/[locale]` segment.
+ */ export const LOCALE_HEADER = 'x-entifix-locale';
+export function isLocale(value) {
+    return typeof value === 'string' && LOCALES.includes(value);
+}
+
+//# sourceMappingURL=locales.js.map

package/dist/i18n/locales.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/locales.ts"],"sourcesContent":["/**\n * The locales the fleet ships. `es` is the default and the fallback: a key that\n * is missing from a catalog resolves against Spanish rather than rendering the\n * raw key, so a half-translated `en` degrades to readable text instead of\n * `controls:table.actions`.\n */\nexport const LOCALES = ['es', 'en'] as const;\n\nexport type Locale = (typeof LOCALES)[number];\n\nexport const DEFAULT_LOCALE: Locale = 'es';\n\n/**\n * Host-scoped so the choice is shared across the fleet's localhost ports in dev,\n * exactly like `entifix_at`/`entifix_sid`. Written by the locale middleware on every\n * redirect, so a visitor who lands on `/en/...` keeps English on the next visit.\n */\nexport const LOCALE_COOKIE = 'entifix_locale';\n\n/**\n * Request header the locale middleware sets when it rewrites a prefixed path.\n * Server components read it instead of a route param, which is what lets the\n * route tree stay free of an `app/[locale]` segment.\n */\nexport const LOCALE_HEADER = 'x-entifix-locale';\n\nexport function isLocale(value: unknown): value is Locale {\n  return (\n    typeof value === 'string' && (LOCALES as readonly string[]).includes(value)\n  );\n}\n"],"names":["LOCALES","DEFAULT_LOCALE","LOCALE_COOKIE","LOCALE_HEADER","isLocale","value","includes"],"mappings":"AAAA;;;;;CAKC,GACD,OAAO,MAAMA,UAAU;IAAC;IAAM;CAAK,CAAU;AAI7C,OAAO,MAAMC,iBAAyB,KAAK;AAE3C;;;;CAIC,GACD,OAAO,MAAMC,gBAAgB,iBAAiB;AAE9C;;;;CAIC,GACD,OAAO,MAAMC,gBAAgB,mBAAmB;AAEhD,OAAO,SAASC,SAASC,KAAc;IACrC,OACE,OAAOA,UAAU,YAAY,AAACL,QAA8BM,QAAQ,CAACD;AAEzE"}