@entifix/core 0.9.0 → 0.10.1

package/dist/failure/generic.js

@@ -0,0 +1,101 @@
+import { Schema } from 'effect';
+import { defineFailure } from './define.js';
+/**
+ * The failures every host shares — the ones a framework route, an adapter or a
+ * transport raises without knowing the domain it serves. A domain names its
+ * own refusals beside these, through the same definers.
+ *
+ * Each code is permanent: a host's message catalog keys on it.
+ */ /** One field a request got wrong. `pointer` locates it, `code` names the rule. */ export const FieldProblem = Schema.Struct({
+    pointer: Schema.String,
+    detail: Schema.String,
+    code: Schema.String
+});
+/** The request breaks rules on its own; every broken one is listed. */ export class Invalid extends defineFailure('invalid')()('Invalid', 'invalid', {
+    errors: Schema.Array(FieldProblem)
+}) {
+}
+/** A list, filter or sort the query language cannot accept. */ export class InvalidQuery extends defineFailure('invalid')()('InvalidQuery', 'invalidQuery', {
+    reason: Schema.String
+}, {
+    message: ({ reason })=>reason
+}) {
+}
+/**
+ * A payload that is not the envelope its reader expected. The sender's fault —
+ * a `400` at an HTTP edge and poison on a bus, where redelivering the same
+ * bytes produces the same refusal.
+ */ export class InvalidEnvelope extends defineFailure('invalid')()('InvalidEnvelope', 'invalidEnvelope', {
+    reason: Schema.String
+}, {
+    message: ({ reason })=>reason
+}) {
+}
+/** No credential, or one that does not verify. */ export class Unauthenticated extends defineFailure('unauthenticated')()('Unauthenticated', 'unauthenticated') {
+}
+/** A verified caller without the grant. */ export class Forbidden extends defineFailure('forbidden')()('Forbidden', 'forbidden', // Which grant was missing: diagnostic, not a leak — the caller already
+// knows what it asked to do.
+{
+    permission: Schema.optionalKey(Schema.String)
+}) {
+}
+/** The addressed record does not exist. */ export class NotFound extends defineFailure('notFound')()('NotFound', 'notFound', {
+    entity: Schema.optionalKey(Schema.String)
+}) {
+}
+/** A write that would duplicate a value the store declares unique. */ export class DuplicateKey extends defineFailure('conflict')()('DuplicateKey', 'duplicateKey', {
+    key: Schema.optionalKey(Schema.String)
+}) {
+}
+/** A third party, or a rule over other records, said no. */ export class Declined extends defineFailure('declined')()('Declined', 'declined', {
+    reason: Schema.optionalKey(Schema.String)
+}, {
+    message: ({ reason })=>reason != null ? reason : ''
+}) {
+}
+/** Lost a race that a retry can win — a claim taken, a transaction aborted. */ export class Contention extends defineFailure('contention')()('Contention', 'contention') {
+}
+/** The dependency asked for less load. Stops retries wherever it appears. */ export class Overloaded extends defineFailure('exhausted')()('Overloaded', 'overloaded', {
+    retryAfterSeconds: Schema.optionalKey(Schema.Number)
+}) {
+}
+/** A dependency could not be reached. */ export class Unavailable extends defineFailure('unavailable')()('Unavailable', 'unavailable', {
+    dependency: Schema.optionalKey(Schema.String)
+}) {
+}
+/** The service a proxy forwards to could not be reached. */ export class UpstreamUnavailable extends defineFailure('unavailable')()('UpstreamUnavailable', 'upstreamUnavailable', {
+    upstream: Schema.optionalKey(Schema.String)
+}) {
+}
+/** A dependency did not answer in time. */ export class Timeout extends defineFailure('timeout')()('Timeout', 'timeout', {
+    dependency: Schema.optionalKey(Schema.String)
+}) {
+}
+/**
+ * A peer answered something that does not decode — a body that is not a
+ * problem, a code nothing registered, a document that does not match its
+ * schema.
+ */ export class ProtocolFailure extends defineFailure('protocol')()('ProtocolFailure', 'protocol', {
+    reason: Schema.String,
+    upstreamStatus: Schema.optionalKey(Schema.Number)
+}, {
+    message: ({ reason })=>reason
+}) {
+}
+/** A bug, surfaced as a value. Never carries the bug's text onto a wire. */ export class Internal extends defineFailure('internal')()('Internal', 'internal') {
+}
+/** An idempotent route was called without its `Idempotency-Key`. */ export class IdempotencyKeyMissing extends defineFailure('invalid')()('IdempotencyKeyMissing', 'idempotencyKeyMissing') {
+}
+/** One `Idempotency-Key` arrived with two different payloads. */ export class IdempotencyKeyReused extends defineFailure('declined')()('IdempotencyKeyReused', 'idempotencyKeyReused') {
+}
+/** The first request under this `Idempotency-Key` has not finished. */ export class IdempotencyKeyInFlight extends defineFailure('contention')()('IdempotencyKeyInFlight', 'idempotencyKeyInFlight') {
+}
+const STORE_FAULT_TAGS = new Set([
+    'Contention',
+    'Unavailable',
+    'Timeout',
+    'ProtocolFailure'
+]);
+/** Whether `value` is a {@link StoreFault}, read by tag. */ export const isStoreFault = (value)=>typeof value === 'object' && value !== null && STORE_FAULT_TAGS.has(value._tag);
+
+//# sourceMappingURL=generic.js.map

package/dist/failure/generic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/failure/generic.ts"],"sourcesContent":["import { Schema } from 'effect';\n\nimport { defineFailure } from './define.js';\n\n/**\n * The failures every host shares — the ones a framework route, an adapter or a\n * transport raises without knowing the domain it serves. A domain names its\n * own refusals beside these, through the same definers.\n *\n * Each code is permanent: a host's message catalog keys on it.\n */\n\n/** One field a request got wrong. `pointer` locates it, `code` names the rule. */\nexport const FieldProblem = Schema.Struct({\n  pointer: Schema.String,\n  detail: Schema.String,\n  code: Schema.String,\n});\nexport type FieldProblem = typeof FieldProblem.Type;\n\n/** The request breaks rules on its own; every broken one is listed. */\nexport class Invalid extends defineFailure('invalid')<Invalid>()(\n  'Invalid',\n  'invalid',\n  { errors: Schema.Array(FieldProblem) },\n) {}\n\n/** A list, filter or sort the query language cannot accept. */\nexport class InvalidQuery extends defineFailure('invalid')<InvalidQuery>()(\n  'InvalidQuery',\n  'invalidQuery',\n  { reason: Schema.String },\n  { message: ({ reason }) => reason },\n) {}\n\n/**\n * A payload that is not the envelope its reader expected. The sender's fault —\n * a `400` at an HTTP edge and poison on a bus, where redelivering the same\n * bytes produces the same refusal.\n */\nexport class InvalidEnvelope extends defineFailure(\n  'invalid',\n)<InvalidEnvelope>()(\n  'InvalidEnvelope',\n  'invalidEnvelope',\n  { reason: Schema.String },\n  { message: ({ reason }) => reason },\n) {}\n\n/** No credential, or one that does not verify. */\nexport class Unauthenticated extends defineFailure(\n  'unauthenticated',\n)<Unauthenticated>()('Unauthenticated', 'unauthenticated') {}\n\n/** A verified caller without the grant. */\nexport class Forbidden extends defineFailure('forbidden')<Forbidden>()(\n  'Forbidden',\n  'forbidden',\n  // Which grant was missing: diagnostic, not a leak — the caller already\n  // knows what it asked to do.\n  { permission: Schema.optionalKey(Schema.String) },\n) {}\n\n/** The addressed record does not exist. */\nexport class NotFound extends defineFailure('notFound')<NotFound>()(\n  'NotFound',\n  'notFound',\n  { entity: Schema.optionalKey(Schema.String) },\n) {}\n\n/** A write that would duplicate a value the store declares unique. */\nexport class DuplicateKey extends defineFailure('conflict')<DuplicateKey>()(\n  'DuplicateKey',\n  'duplicateKey',\n  { key: Schema.optionalKey(Schema.String) },\n) {}\n\n/** A third party, or a rule over other records, said no. */\nexport class Declined extends defineFailure('declined')<Declined>()(\n  'Declined',\n  'declined',\n  { reason: Schema.optionalKey(Schema.String) },\n  { message: ({ reason }) => reason ?? '' },\n) {}\n\n/** Lost a race that a retry can win — a claim taken, a transaction aborted. */\nexport class Contention extends defineFailure('contention')<Contention>()(\n  'Contention',\n  'contention',\n) {}\n\n/** The dependency asked for less load. Stops retries wherever it appears. */\nexport class Overloaded extends defineFailure('exhausted')<Overloaded>()(\n  'Overloaded',\n  'overloaded',\n  { retryAfterSeconds: Schema.optionalKey(Schema.Number) },\n) {}\n\n/** A dependency could not be reached. */\nexport class Unavailable extends defineFailure('unavailable')<Unavailable>()(\n  'Unavailable',\n  'unavailable',\n  { dependency: Schema.optionalKey(Schema.String) },\n) {}\n\n/** The service a proxy forwards to could not be reached. */\nexport class UpstreamUnavailable extends defineFailure(\n  'unavailable',\n)<UpstreamUnavailable>()('UpstreamUnavailable', 'upstreamUnavailable', {\n  upstream: Schema.optionalKey(Schema.String),\n}) {}\n\n/** A dependency did not answer in time. */\nexport class Timeout extends defineFailure('timeout')<Timeout>()(\n  'Timeout',\n  'timeout',\n  { dependency: Schema.optionalKey(Schema.String) },\n) {}\n\n/**\n * A peer answered something that does not decode — a body that is not a\n * problem, a code nothing registered, a document that does not match its\n * schema.\n */\nexport class ProtocolFailure extends defineFailure(\n  'protocol',\n)<ProtocolFailure>()(\n  'ProtocolFailure',\n  'protocol',\n  {\n    reason: Schema.String,\n    upstreamStatus: Schema.optionalKey(Schema.Number),\n  },\n  { message: ({ reason }) => reason },\n) {}\n\n/** A bug, surfaced as a value. Never carries the bug's text onto a wire. */\nexport class Internal extends defineFailure('internal')<Internal>()(\n  'Internal',\n  'internal',\n) {}\n\n/** An idempotent route was called without its `Idempotency-Key`. */\nexport class IdempotencyKeyMissing extends defineFailure(\n  'invalid',\n)<IdempotencyKeyMissing>()('IdempotencyKeyMissing', 'idempotencyKeyMissing') {}\n\n/** One `Idempotency-Key` arrived with two different payloads. */\nexport class IdempotencyKeyReused extends defineFailure(\n  'declined',\n)<IdempotencyKeyReused>()('IdempotencyKeyReused', 'idempotencyKeyReused') {}\n\n/** The first request under this `Idempotency-Key` has not finished. */\nexport class IdempotencyKeyInFlight extends defineFailure(\n  'contention',\n)<IdempotencyKeyInFlight>()(\n  'IdempotencyKeyInFlight',\n  'idempotencyKeyInFlight',\n) {}\n\n/**\n * What a store adapter fails with — a datastore, a cache, a bus: the value it\n * guarded already exists, someone else got there first, it could not be\n * reached, it did not answer in time, or it answered something unreadable.\n * A port that talks to storage names this as its failure.\n */\nexport type StoreFailure =\n  DuplicateKey | Contention | Unavailable | Timeout | ProtocolFailure;\n\n/**\n * The technical part of {@link StoreFailure}: the store failing to answer, as\n * opposed to answering no. A unit of work rolls back and surfaces these; a\n * business failure — a `DuplicateKey` included — is its abort.\n */\nexport type StoreFault = Exclude<StoreFailure, DuplicateKey>;\n\nconst STORE_FAULT_TAGS: ReadonlySet<string> = new Set([\n  'Contention',\n  'Unavailable',\n  'Timeout',\n  'ProtocolFailure',\n]);\n\n/** Whether `value` is a {@link StoreFault}, read by tag. */\nexport const isStoreFault = (value: unknown): value is StoreFault =>\n  typeof value === 'object' &&\n  value !== null &&\n  STORE_FAULT_TAGS.has((value as { readonly _tag?: unknown })._tag as string);\n"],"names":["Schema","defineFailure","FieldProblem","Struct","pointer","String","detail","code","Invalid","errors","Array","InvalidQuery","reason","message","InvalidEnvelope","Unauthenticated","Forbidden","permission","optionalKey","NotFound","entity","DuplicateKey","key","Declined","Contention","Overloaded","retryAfterSeconds","Number","Unavailable","dependency","UpstreamUnavailable","upstream","Timeout","ProtocolFailure","upstreamStatus","Internal","IdempotencyKeyMissing","IdempotencyKeyReused","IdempotencyKeyInFlight","STORE_FAULT_TAGS","Set","isStoreFault","value","has","_tag"],"mappings":"AAAA,SAASA,MAAM,QAAQ,SAAS;AAEhC,SAASC,aAAa,QAAQ,cAAc;AAE5C;;;;;;CAMC,GAED,gFAAgF,GAChF,OAAO,MAAMC,eAAeF,OAAOG,MAAM,CAAC;IACxCC,SAASJ,OAAOK,MAAM;IACtBC,QAAQN,OAAOK,MAAM;IACrBE,MAAMP,OAAOK,MAAM;AACrB,GAAG;AAGH,qEAAqE,GACrE,OAAO,MAAMG,gBAAgBP,cAAc,aACzC,WACA,WACA;IAAEQ,QAAQT,OAAOU,KAAK,CAACR;AAAc;AACpC;AAEH,6DAA6D,GAC7D,OAAO,MAAMS,qBAAqBV,cAAc,aAC9C,gBACA,gBACA;IAAEW,QAAQZ,OAAOK,MAAM;AAAC,GACxB;IAAEQ,SAAS,CAAC,EAAED,MAAM,EAAE,GAAKA;AAAO;AACjC;AAEH;;;;CAIC,GACD,OAAO,MAAME,wBAAwBb,cACnC,aAEA,mBACA,mBACA;IAAEW,QAAQZ,OAAOK,MAAM;AAAC,GACxB;IAAEQ,SAAS,CAAC,EAAED,MAAM,EAAE,GAAKA;AAAO;AACjC;AAEH,gDAAgD,GAChD,OAAO,MAAMG,wBAAwBd,cACnC,qBACmB,mBAAmB;AAAoB;AAE5D,yCAAyC,GACzC,OAAO,MAAMe,kBAAkBf,cAAc,eAC3C,aACA,aACA,uEAAuE;AACvE,6BAA6B;AAC7B;IAAEgB,YAAYjB,OAAOkB,WAAW,CAAClB,OAAOK,MAAM;AAAE;AAC/C;AAEH,yCAAyC,GACzC,OAAO,MAAMc,iBAAiBlB,cAAc,cAC1C,YACA,YACA;IAAEmB,QAAQpB,OAAOkB,WAAW,CAAClB,OAAOK,MAAM;AAAE;AAC3C;AAEH,oEAAoE,GACpE,OAAO,MAAMgB,qBAAqBpB,cAAc,cAC9C,gBACA,gBACA;IAAEqB,KAAKtB,OAAOkB,WAAW,CAAClB,OAAOK,MAAM;AAAE;AACxC;AAEH,0DAA0D,GAC1D,OAAO,MAAMkB,iBAAiBtB,cAAc,cAC1C,YACA,YACA;IAAEW,QAAQZ,OAAOkB,WAAW,CAAClB,OAAOK,MAAM;AAAE,GAC5C;IAAEQ,SAAS,CAAC,EAAED,MAAM,EAAE,GAAKA,iBAAAA,SAAU;AAAG;AACvC;AAEH,6EAA6E,GAC7E,OAAO,MAAMY,mBAAmBvB,cAAc,gBAC5C,cACA;AACC;AAEH,2EAA2E,GAC3E,OAAO,MAAMwB,mBAAmBxB,cAAc,eAC5C,cACA,cACA;IAAEyB,mBAAmB1B,OAAOkB,WAAW,CAAClB,OAAO2B,MAAM;AAAE;AACtD;AAEH,uCAAuC,GACvC,OAAO,MAAMC,oBAAoB3B,cAAc,iBAC7C,eACA,eACA;IAAE4B,YAAY7B,OAAOkB,WAAW,CAAClB,OAAOK,MAAM;AAAE;AAC/C;AAEH,0DAA0D,GAC1D,OAAO,MAAMyB,4BAA4B7B,cACvC,iBACuB,uBAAuB,uBAAuB;IACrE8B,UAAU/B,OAAOkB,WAAW,CAAClB,OAAOK,MAAM;AAC5C;AAAI;AAEJ,yCAAyC,GACzC,OAAO,MAAM2B,gBAAgB/B,cAAc,aACzC,WACA,WACA;IAAE4B,YAAY7B,OAAOkB,WAAW,CAAClB,OAAOK,MAAM;AAAE;AAC/C;AAEH;;;;CAIC,GACD,OAAO,MAAM4B,wBAAwBhC,cACnC,cAEA,mBACA,YACA;IACEW,QAAQZ,OAAOK,MAAM;IACrB6B,gBAAgBlC,OAAOkB,WAAW,CAAClB,OAAO2B,MAAM;AAClD,GACA;IAAEd,SAAS,CAAC,EAAED,MAAM,EAAE,GAAKA;AAAO;AACjC;AAEH,0EAA0E,GAC1E,OAAO,MAAMuB,iBAAiBlC,cAAc,cAC1C,YACA;AACC;AAEH,kEAAkE,GAClE,OAAO,MAAMmC,8BAA8BnC,cACzC,aACyB,yBAAyB;AAA0B;AAE9E,+DAA+D,GAC/D,OAAO,MAAMoC,6BAA6BpC,cACxC,cACwB,wBAAwB;AAAyB;AAE3E,qEAAqE,GACrE,OAAO,MAAMqC,+BAA+BrC,cAC1C,gBAEA,0BACA;AACC;AAkBH,MAAMsC,mBAAwC,IAAIC,IAAI;IACpD;IACA;IACA;IACA;CACD;AAED,0DAA0D,GAC1D,OAAO,MAAMC,eAAe,CAACC,QAC3B,OAAOA,UAAU,YACjBA,UAAU,QACVH,iBAAiBI,GAAG,CAAC,AAACD,MAAsCE,IAAI,EAAY"}

package/dist/failure/index.d.ts

@@ -0,0 +1,50 @@
+export * from './failure.js';
+export * from './generic.js';
+export * from './predicates.js';
+export * from './problem.js';
+export * from './registry.js';
+/**
+ * Everything a host needs to define and match failures, under one name
+ * ([ADR 0013](../../../../../docs/adr/0013-failures-are-typed-values-decided-at-the-shell.md)).
+ *
+ * ```ts
+ * class DuplicateSlug extends Failure.conflict<DuplicateSlug>()(
+ *   'DuplicateSlug',
+ *   'duplicateSlug',
+ *   { slug: Schema.String },
+ * ) {}
+ *
+ * effect.pipe(Effect.catchIf(Failure.isCategory('conflict'), …))
+ * ```
+ */
+export declare const Failure: {
+    readonly invalid: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "invalid">>;
+    readonly unauthenticated: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "unauthenticated">>;
+    readonly forbidden: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "forbidden">>;
+    readonly notFound: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "notFound">>;
+    readonly conflict: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "conflict">>;
+    readonly declined: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "declined">>;
+    readonly contention: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "contention">>;
+    readonly exhausted: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "exhausted">>;
+    readonly unavailable: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "unavailable">>;
+    readonly timeout: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "timeout">>;
+    readonly protocol: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "protocol">>;
+    readonly internal: <Self = never>() => <const Tag extends string, const Code extends string, const Fields extends import("effect/Schema").Struct.Fields = Record<never, never>>(tag: Tag, code: Code, fields?: Fields, options?: import("./define.js").FailureOptions<import("effect/Schema").Struct.Type<Fields>>) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Schema.TaggedError<Self>(...)`" : import("effect/Schema").Class<Self, import("effect/Schema").TaggedStruct<Tag, Fields>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<Code, "internal">>;
+    readonly is: import("./predicates.js").FailureGuard<import("./failure.js").EntifixFailure<string, string, import("./failure.js").FailureCategory>>;
+    readonly isTag: <const Tag extends string>(tag: Tag) => import("./predicates.js").FailureGuard<{
+        readonly _tag: Tag;
+    }>;
+    readonly isCategory: <const C extends import("./failure.js").FailureCategory>(category: C) => import("./predicates.js").FailureGuard<{
+        readonly category: C;
+    }>;
+    readonly isFamily: <const F extends import("./failure.js").FailureFamily>(family: F) => import("./predicates.js").FailureGuard<{
+        readonly family: F;
+    }>;
+    readonly and: <A, B>(left: import("./predicates.js").FailureGuard<A>, right: import("./predicates.js").FailureGuard<B>) => import("./predicates.js").FailureGuard<A & B>;
+    readonly or: <A, B>(left: import("./predicates.js").FailureGuard<A>, right: import("./predicates.js").FailureGuard<B>) => import("./predicates.js").FailureGuard<A | B>;
+    readonly not: <S>(guard: import("./predicates.js").FailureGuard<S>) => <E>(value: E) => value is Exclude<E, S>;
+    readonly when: <Shape, R = never>(guard: import("./predicates.js").FailureGuard<Shape>, condition: (failure: Shape) => import("effect/Effect").Effect<boolean, never, R>) => import("./predicates.js").EffectfulFailurePredicate<Shape, R>;
+    readonly lookup: (code: string) => import("./registry.js").RegisteredFailure | undefined;
+    readonly registered: () => readonly import("./registry.js").RegisteredFailure[];
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/failure/index.ts"],"names":[],"mappings":"AAaA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO;2CAwBqR,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;mDAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;6CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;4CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;4CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;4CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;8CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;6CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;+CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;2CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;4CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;4CAAxP,wBAA6B,EAAC,yBAA8B,EAAC,iFAAqE,EAAM,QAAa,EAAC,UAAe,EAAC,eAAoB,EAAC,2FAA6D;;;;;;;;;;;;;4EAA89B,CAAC,EAAE,QAAQ;;;;CADhgD,CAAC"}

package/dist/failure/index.js

@@ -0,0 +1,47 @@
+import { defineFailure } from './define.js';
+import { and, isCategory, isFailure, isFamily, isTag, not, or, when } from './predicates.js';
+import { lookupFailure, registeredFailures } from './registry.js';
+export * from './failure.js';
+export * from './generic.js';
+export * from './predicates.js';
+export * from './problem.js';
+export * from './registry.js';
+/**
+ * Everything a host needs to define and match failures, under one name
+ * ([ADR 0013](../../../../../docs/adr/0013-failures-are-typed-values-decided-at-the-shell.md)).
+ *
+ * ```ts
+ * class DuplicateSlug extends Failure.conflict<DuplicateSlug>()(
+ *   'DuplicateSlug',
+ *   'duplicateSlug',
+ *   { slug: Schema.String },
+ * ) {}
+ *
+ * effect.pipe(Effect.catchIf(Failure.isCategory('conflict'), …))
+ * ```
+ */ export const Failure = {
+    invalid: defineFailure('invalid'),
+    unauthenticated: defineFailure('unauthenticated'),
+    forbidden: defineFailure('forbidden'),
+    notFound: defineFailure('notFound'),
+    conflict: defineFailure('conflict'),
+    declined: defineFailure('declined'),
+    contention: defineFailure('contention'),
+    exhausted: defineFailure('exhausted'),
+    unavailable: defineFailure('unavailable'),
+    timeout: defineFailure('timeout'),
+    protocol: defineFailure('protocol'),
+    internal: defineFailure('internal'),
+    is: isFailure,
+    isTag,
+    isCategory,
+    isFamily,
+    and,
+    or,
+    not,
+    when,
+    lookup: lookupFailure,
+    registered: registeredFailures
+};
+
+//# sourceMappingURL=index.js.map

package/dist/failure/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/failure/index.ts"],"sourcesContent":["import { defineFailure } from './define.js';\nimport {\n  and,\n  isCategory,\n  isFailure,\n  isFamily,\n  isTag,\n  not,\n  or,\n  when,\n} from './predicates.js';\nimport { lookupFailure, registeredFailures } from './registry.js';\n\nexport * from './failure.js';\nexport * from './generic.js';\nexport * from './predicates.js';\nexport * from './problem.js';\nexport * from './registry.js';\n\n/**\n * Everything a host needs to define and match failures, under one name\n * ([ADR 0013](../../../../../docs/adr/0013-failures-are-typed-values-decided-at-the-shell.md)).\n *\n * ```ts\n * class DuplicateSlug extends Failure.conflict<DuplicateSlug>()(\n *   'DuplicateSlug',\n *   'duplicateSlug',\n *   { slug: Schema.String },\n * ) {}\n *\n * effect.pipe(Effect.catchIf(Failure.isCategory('conflict'), …))\n * ```\n */\nexport const Failure = {\n  invalid: defineFailure('invalid'),\n  unauthenticated: defineFailure('unauthenticated'),\n  forbidden: defineFailure('forbidden'),\n  notFound: defineFailure('notFound'),\n  conflict: defineFailure('conflict'),\n  declined: defineFailure('declined'),\n  contention: defineFailure('contention'),\n  exhausted: defineFailure('exhausted'),\n  unavailable: defineFailure('unavailable'),\n  timeout: defineFailure('timeout'),\n  protocol: defineFailure('protocol'),\n  internal: defineFailure('internal'),\n  is: isFailure,\n  isTag,\n  isCategory,\n  isFamily,\n  and,\n  or,\n  not,\n  when,\n  lookup: lookupFailure,\n  registered: registeredFailures,\n} as const;\n"],"names":["defineFailure","and","isCategory","isFailure","isFamily","isTag","not","or","when","lookupFailure","registeredFailures","Failure","invalid","unauthenticated","forbidden","notFound","conflict","declined","contention","exhausted","unavailable","timeout","protocol","internal","is","lookup","registered"],"mappings":"AAAA,SAASA,aAAa,QAAQ,cAAc;AAC5C,SACEC,GAAG,EACHC,UAAU,EACVC,SAAS,EACTC,QAAQ,EACRC,KAAK,EACLC,GAAG,EACHC,EAAE,EACFC,IAAI,QACC,kBAAkB;AACzB,SAASC,aAAa,EAAEC,kBAAkB,QAAQ,gBAAgB;AAElE,cAAc,eAAe;AAC7B,cAAc,eAAe;AAC7B,cAAc,kBAAkB;AAChC,cAAc,eAAe;AAC7B,cAAc,gBAAgB;AAE9B;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMC,UAAU;IACrBC,SAASZ,cAAc;IACvBa,iBAAiBb,cAAc;IAC/Bc,WAAWd,cAAc;IACzBe,UAAUf,cAAc;IACxBgB,UAAUhB,cAAc;IACxBiB,UAAUjB,cAAc;IACxBkB,YAAYlB,cAAc;IAC1BmB,WAAWnB,cAAc;IACzBoB,aAAapB,cAAc;IAC3BqB,SAASrB,cAAc;IACvBsB,UAAUtB,cAAc;IACxBuB,UAAUvB,cAAc;IACxBwB,IAAIrB;IACJE;IACAH;IACAE;IACAH;IACAM;IACAD;IACAE;IACAiB,QAAQhB;IACRiB,YAAYhB;AACd,EAAW"}

package/dist/failure/predicates.d.ts

@@ -0,0 +1,56 @@
+import type { Effect } from 'effect';
+import type { EntifixFailure, FailureCategory, FailureFamily } from './failure.js';
+/**
+ * A guard over anything, naming the shape it admits.
+ *
+ * It is written over `unknown` rather than over a failure union on purpose:
+ * TypeScript narrows a union by a guard on a supertype by **filtering** its
+ * members, so `if (isCategory('conflict')(e))` leaves exactly the members of
+ * `E` whose `category` is `'conflict'` — the same as `Extract<E, Shape>` — and
+ * one predicate serves every union it is applied to.
+ *
+ * The check reads `_tag`, `category` and `family` and never the prototype, so a
+ * failure decoded off a wire or defined in a second copy of this module
+ * matches exactly as one constructed in place.
+ */
+export type FailureGuard<Shape> = (value: unknown) => value is Shape;
+/** Admits the failure whose `_tag` is `tag`. */
+export declare const isTag: <const Tag extends string>(tag: Tag) => FailureGuard<{
+    readonly _tag: Tag;
+}>;
+/** Admits every failure in `category`. */
+export declare const isCategory: <const C extends FailureCategory>(category: C) => FailureGuard<{
+    readonly category: C;
+}>;
+/** Admits every failure in `family`. */
+export declare const isFamily: <const F extends FailureFamily>(family: F) => FailureGuard<{
+    readonly family: F;
+}>;
+/** Admits any `EntifixFailure`, of any category. */
+export declare const isFailure: FailureGuard<EntifixFailure>;
+/** Both guards admit it. */
+export declare const and: <A, B>(left: FailureGuard<A>, right: FailureGuard<B>) => FailureGuard<A & B>;
+/** Either guard admits it. */
+export declare const or: <A, B>(left: FailureGuard<A>, right: FailureGuard<B>) => FailureGuard<A | B>;
+/**
+ * The guard does not admit it.
+ *
+ * ⚠️ Generic over the union it is applied to, because "not this shape" has no
+ * shape of its own: `not(isFamily('business'))(e)` narrows `E` to
+ * `Exclude<E, { family: 'business' }>`. Applied with no union in view — as an
+ * argument to {@link and} or {@link or} — it admits correctly and narrows
+ * nothing, so keep it the outermost combinator.
+ */
+export declare const not: <S>(guard: FailureGuard<S>) => <E>(value: E) => value is Exclude<E, S>;
+/**
+ * A guard plus a condition that needs the request — a dial read from
+ * configuration, the caller's organization. The guard narrows; the condition
+ * decides, and it is an Effect because the context it reads is.
+ */
+export interface EffectfulFailurePredicate<Shape, R = never> {
+    readonly guard: FailureGuard<Shape>;
+    readonly condition: (failure: Shape) => Effect.Effect<boolean, never, R>;
+}
+/** Pairs a guard with a condition read from the request's context. */
+export declare const when: <Shape, R = never>(guard: FailureGuard<Shape>, condition: (failure: Shape) => Effect.Effect<boolean, never, R>) => EffectfulFailurePredicate<Shape, R>;
+//# sourceMappingURL=predicates.d.ts.map

package/dist/failure/predicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.d.ts","sourceRoot":"","sources":["../../src/failure/predicates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,aAAa,EACd,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,CAAC,KAAK,IAAI,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,KAAK,CAAC;AAOrE,gDAAgD;AAChD,eAAO,MAAM,KAAK,GACf,KAAK,CAAC,GAAG,SAAS,MAAM,EAAE,KAAK,GAAG,KAAG,YAAY,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAE5C,CAAC;AAEhC,0CAA0C;AAC1C,eAAO,MAAM,UAAU,GACpB,KAAK,CAAC,CAAC,SAAS,eAAe,EAC9B,UAAU,CAAC,KACV,YAAY,CAAC;IAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;CAAE,CAEF,CAAC;AAEzC,wCAAwC;AACxC,eAAO,MAAM,QAAQ,GAClB,KAAK,CAAC,CAAC,SAAS,aAAa,EAC5B,QAAQ,CAAC,KACR,YAAY,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAEJ,CAAC;AAErC,oDAAoD;AACpD,eAAO,MAAM,SAAS,EAAE,YAAY,CAAC,cAAc,CAOiB,CAAC;AAErE,4BAA4B;AAC5B,eAAO,MAAM,GAAG,GACb,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,YAAY,CAAC,CAAC,CAAC,KAAG,YAAY,CAAC,CAAC,GAAG,CAAC,CAE5C,CAAC;AAEhC,8BAA8B;AAC9B,eAAO,MAAM,EAAE,GACZ,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,YAAY,CAAC,CAAC,CAAC,KAAG,YAAY,CAAC,CAAC,GAAG,CAAC,CAE5C,CAAC;AAEhC;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,GACb,CAAC,EAAE,OAAO,YAAY,CAAC,CAAC,CAAC,MACzB,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CACrB,CAAC;AAElB;;;;GAIG;AACH,MAAM,WAAW,yBAAyB,CAAC,KAAK,EAAE,CAAC,GAAG,KAAK;IACzD,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;CAC1E;AAED,sEAAsE;AACtE,eAAO,MAAM,IAAI,GAAI,KAAK,EAAE,CAAC,GAAG,KAAK,EACnC,OAAO,YAAY,CAAC,KAAK,CAAC,EAC1B,WAAW,CAAC,OAAO,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAC9D,yBAAyB,CAAC,KAAK,EAAE,CAAC,CAA2B,CAAC"}

package/dist/failure/predicates.js

@@ -0,0 +1,22 @@
+const readsAs = (value, key, expected)=>typeof value === 'object' && value !== null && value[key] === expected;
+/** Admits the failure whose `_tag` is `tag`. */ export const isTag = (tag)=>(value)=>readsAs(value, '_tag', tag);
+/** Admits every failure in `category`. */ export const isCategory = (category)=>(value)=>readsAs(value, 'category', category);
+/** Admits every failure in `family`. */ export const isFamily = (family)=>(value)=>readsAs(value, 'family', family);
+/** Admits any `EntifixFailure`, of any category. */ export const isFailure = (value)=>typeof value === 'object' && value !== null && typeof value['_tag'] === 'string' && typeof value['code'] === 'string' && typeof value['category'] === 'string';
+/** Both guards admit it. */ export const and = (left, right)=>(value)=>left(value) && right(value);
+/** Either guard admits it. */ export const or = (left, right)=>(value)=>left(value) || right(value);
+/**
+ * The guard does not admit it.
+ *
+ * ⚠️ Generic over the union it is applied to, because "not this shape" has no
+ * shape of its own: `not(isFamily('business'))(e)` narrows `E` to
+ * `Exclude<E, { family: 'business' }>`. Applied with no union in view — as an
+ * argument to {@link and} or {@link or} — it admits correctly and narrows
+ * nothing, so keep it the outermost combinator.
+ */ export const not = (guard)=>(value)=>!guard(value);
+/** Pairs a guard with a condition read from the request's context. */ export const when = (guard, condition)=>({
+        guard,
+        condition
+    });
+
+//# sourceMappingURL=predicates.js.map

package/dist/failure/predicates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/failure/predicates.ts"],"sourcesContent":["import type { Effect } from 'effect';\n\nimport type {\n  EntifixFailure,\n  FailureCategory,\n  FailureFamily,\n} from './failure.js';\n\n/**\n * A guard over anything, naming the shape it admits.\n *\n * It is written over `unknown` rather than over a failure union on purpose:\n * TypeScript narrows a union by a guard on a supertype by **filtering** its\n * members, so `if (isCategory('conflict')(e))` leaves exactly the members of\n * `E` whose `category` is `'conflict'` — the same as `Extract<E, Shape>` — and\n * one predicate serves every union it is applied to.\n *\n * The check reads `_tag`, `category` and `family` and never the prototype, so a\n * failure decoded off a wire or defined in a second copy of this module\n * matches exactly as one constructed in place.\n */\nexport type FailureGuard<Shape> = (value: unknown) => value is Shape;\n\nconst readsAs = (value: unknown, key: string, expected: string): boolean =>\n  typeof value === 'object' &&\n  value !== null &&\n  (value as Record<string, unknown>)[key] === expected;\n\n/** Admits the failure whose `_tag` is `tag`. */\nexport const isTag =\n  <const Tag extends string>(tag: Tag): FailureGuard<{ readonly _tag: Tag }> =>\n  (value): value is { readonly _tag: Tag } =>\n    readsAs(value, '_tag', tag);\n\n/** Admits every failure in `category`. */\nexport const isCategory =\n  <const C extends FailureCategory>(\n    category: C,\n  ): FailureGuard<{ readonly category: C }> =>\n  (value): value is { readonly category: C } =>\n    readsAs(value, 'category', category);\n\n/** Admits every failure in `family`. */\nexport const isFamily =\n  <const F extends FailureFamily>(\n    family: F,\n  ): FailureGuard<{ readonly family: F }> =>\n  (value): value is { readonly family: F } =>\n    readsAs(value, 'family', family);\n\n/** Admits any `EntifixFailure`, of any category. */\nexport const isFailure: FailureGuard<EntifixFailure> = (\n  value,\n): value is EntifixFailure =>\n  typeof value === 'object' &&\n  value !== null &&\n  typeof (value as Record<string, unknown>)['_tag'] === 'string' &&\n  typeof (value as Record<string, unknown>)['code'] === 'string' &&\n  typeof (value as Record<string, unknown>)['category'] === 'string';\n\n/** Both guards admit it. */\nexport const and =\n  <A, B>(left: FailureGuard<A>, right: FailureGuard<B>): FailureGuard<A & B> =>\n  (value): value is A & B =>\n    left(value) && right(value);\n\n/** Either guard admits it. */\nexport const or =\n  <A, B>(left: FailureGuard<A>, right: FailureGuard<B>): FailureGuard<A | B> =>\n  (value): value is A | B =>\n    left(value) || right(value);\n\n/**\n * The guard does not admit it.\n *\n * ⚠️ Generic over the union it is applied to, because \"not this shape\" has no\n * shape of its own: `not(isFamily('business'))(e)` narrows `E` to\n * `Exclude<E, { family: 'business' }>`. Applied with no union in view — as an\n * argument to {@link and} or {@link or} — it admits correctly and narrows\n * nothing, so keep it the outermost combinator.\n */\nexport const not =\n  <S>(guard: FailureGuard<S>) =>\n  <E>(value: E): value is Exclude<E, S> =>\n    !guard(value);\n\n/**\n * A guard plus a condition that needs the request — a dial read from\n * configuration, the caller's organization. The guard narrows; the condition\n * decides, and it is an Effect because the context it reads is.\n */\nexport interface EffectfulFailurePredicate<Shape, R = never> {\n  readonly guard: FailureGuard<Shape>;\n  readonly condition: (failure: Shape) => Effect.Effect<boolean, never, R>;\n}\n\n/** Pairs a guard with a condition read from the request's context. */\nexport const when = <Shape, R = never>(\n  guard: FailureGuard<Shape>,\n  condition: (failure: Shape) => Effect.Effect<boolean, never, R>,\n): EffectfulFailurePredicate<Shape, R> => ({ guard, condition });\n"],"names":["readsAs","value","key","expected","isTag","tag","isCategory","category","isFamily","family","isFailure","and","left","right","or","not","guard","when","condition"],"mappings":"AAuBA,MAAMA,UAAU,CAACC,OAAgBC,KAAaC,WAC5C,OAAOF,UAAU,YACjBA,UAAU,QACV,AAACA,KAAiC,CAACC,IAAI,KAAKC;AAE9C,8CAA8C,GAC9C,OAAO,MAAMC,QACX,CAA2BC,MAC3B,CAACJ,QACCD,QAAQC,OAAO,QAAQI,KAAK;AAEhC,wCAAwC,GACxC,OAAO,MAAMC,aACX,CACEC,WAEF,CAACN,QACCD,QAAQC,OAAO,YAAYM,UAAU;AAEzC,sCAAsC,GACtC,OAAO,MAAMC,WACX,CACEC,SAEF,CAACR,QACCD,QAAQC,OAAO,UAAUQ,QAAQ;AAErC,kDAAkD,GAClD,OAAO,MAAMC,YAA0C,CACrDT,QAEA,OAAOA,UAAU,YACjBA,UAAU,QACV,OAAO,AAACA,KAAiC,CAAC,OAAO,KAAK,YACtD,OAAO,AAACA,KAAiC,CAAC,OAAO,KAAK,YACtD,OAAO,AAACA,KAAiC,CAAC,WAAW,KAAK,SAAS;AAErE,0BAA0B,GAC1B,OAAO,MAAMU,MACX,CAAOC,MAAuBC,QAC9B,CAACZ,QACCW,KAAKX,UAAUY,MAAMZ,OAAO;AAEhC,4BAA4B,GAC5B,OAAO,MAAMa,KACX,CAAOF,MAAuBC,QAC9B,CAACZ,QACCW,KAAKX,UAAUY,MAAMZ,OAAO;AAEhC;;;;;;;;CAQC,GACD,OAAO,MAAMc,MACX,CAAIC,QACJ,CAAIf,QACF,CAACe,MAAMf,OAAO;AAYlB,oEAAoE,GACpE,OAAO,MAAMgB,OAAO,CAClBD,OACAE,YACyC,CAAA;QAAEF;QAAOE;IAAU,CAAA,EAAG"}

package/dist/failure/problem.d.ts

@@ -0,0 +1,49 @@
+import { Schema } from 'effect';
+import { type EntifixFailure } from './failure.js';
+/** The content type every error answer carries (RFC 9457). */
+export declare const PROBLEM_CONTENT_TYPE = "application/problem+json";
+/**
+ * The envelope of an RFC 9457 problem, with entifix's members beside the
+ * standard ones. `code` is top-level because it is what a client translates;
+ * the failure's own fields ride as extension members.
+ */
+export declare const Problem: Schema.Struct<{
+    readonly type: Schema.String;
+    readonly title: Schema.String;
+    readonly status: Schema.Number;
+    readonly code: Schema.String;
+    readonly category: Schema.Literals<readonly import("./failure.js").FailureCategory[]>;
+    readonly detail: Schema.optionalKey<Schema.String>;
+    readonly instance: Schema.optionalKey<Schema.String>;
+    readonly traceId: Schema.optionalKey<Schema.String>;
+}>;
+/** A problem body: the envelope plus the failure's own fields. */
+export type Problem = typeof Problem.Type & Readonly<Record<string, unknown>>;
+export interface ProblemOptions {
+    /** The status to answer with; the category's default when absent. */
+    readonly status?: number;
+    readonly traceId?: string;
+    /** The request path the failure answers. */
+    readonly instance?: string;
+}
+/**
+ * The problem body a failure answers with.
+ *
+ * `detail` is the failure's `message` when it has one, and is never
+ * `String(error)`: a failure's message is written by its author for a reader,
+ * a defect's text is not, and a defect never reaches this function.
+ */
+export declare const problemOf: (failure: EntifixFailure, options?: ProblemOptions) => Problem;
+/**
+ * The failure a problem body names, with its typed fields — or a
+ * {@link ProtocolFailure} when the body is not a problem, names a code nothing
+ * registered, or carries fields that do not decode.
+ *
+ * Never throws and never fails: whatever a peer sends, the caller gets a
+ * failure it can branch on.
+ *
+ * @param status the HTTP status the body arrived with, kept on a
+ *   `ProtocolFailure` so the caller still knows what the peer meant.
+ */
+export declare const decodeProblem: (body: unknown, status?: number) => EntifixFailure;
+//# sourceMappingURL=problem.d.ts.map

package/dist/failure/problem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"problem.d.ts","sourceRoot":"","sources":["../../src/failure/problem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,cAAc,CAAC;AAItB,8DAA8D;AAC9D,eAAO,MAAM,oBAAoB,6BAA6B,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,OAAO;;;;;;;;;EASlB,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAE9E,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AA0BD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GACpB,SAAS,cAAc,EACvB,UAAS,cAAmB,KAC3B,OAUD,CAAC;AAKH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GACxB,MAAM,OAAO,EACb,SAAS,MAAM,KACd,cAqBF,CAAC"}

package/dist/failure/problem.js

@@ -0,0 +1,87 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { Exit, Schema } from 'effect';
+import { defaultStatus, FAILURE_CATEGORIES } from './failure.js';
+import { ProtocolFailure } from './generic.js';
+import { failureTypeUri, lookupFailure } from './registry.js';
+/** The content type every error answer carries (RFC 9457). */ export const PROBLEM_CONTENT_TYPE = 'application/problem+json';
+/**
+ * The envelope of an RFC 9457 problem, with entifix's members beside the
+ * standard ones. `code` is top-level because it is what a client translates;
+ * the failure's own fields ride as extension members.
+ */ export const Problem = Schema.Struct({
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number,
+    code: Schema.String,
+    category: Schema.Literals(FAILURE_CATEGORIES),
+    detail: Schema.optionalKey(Schema.String),
+    instance: Schema.optionalKey(Schema.String),
+    traceId: Schema.optionalKey(Schema.String)
+});
+/**
+ * The failure's own fields, encoded by the class that registered its code.
+ *
+ * ⚠️ Encoded through the **registered** class, not the instance's
+ * constructor, so a failure decoded elsewhere encodes the same way. A failure
+ * whose code nothing registered — impossible through the definers — encodes
+ * with no fields rather than leaking whatever it carries.
+ */ const encodedFields = (failure)=>{
+    const registered = lookupFailure(failure.code);
+    if (registered === undefined) return {};
+    const encoded = Schema.encodeUnknownExit(registered.failureClass)(failure);
+    if (Exit.isFailure(encoded)) return {};
+    const _encoded_value = encoded.value, { _tag: _ignored } = _encoded_value, fields = _object_without_properties_loose(_encoded_value, [
+        "_tag"
+    ]);
+    return fields;
+};
+/**
+ * The problem body a failure answers with.
+ *
+ * `detail` is the failure's `message` when it has one, and is never
+ * `String(error)`: a failure's message is written by its author for a reader,
+ * a defect's text is not, and a defect never reaches this function.
+ */ export const problemOf = (failure, options = {})=>{
+    var _options_status;
+    return _extends({}, encodedFields(failure), {
+        type: failureTypeUri(failure.code),
+        title: failure._tag,
+        status: (_options_status = options.status) != null ? _options_status : defaultStatus(failure.category),
+        code: failure.code,
+        category: failure.category
+    }, failure.message === '' ? {} : {
+        detail: failure.message
+    }, options.instance === undefined ? {} : {
+        instance: options.instance
+    }, options.traceId === undefined ? {} : {
+        traceId: options.traceId
+    });
+};
+const isRecord = (value)=>typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * The failure a problem body names, with its typed fields — or a
+ * {@link ProtocolFailure} when the body is not a problem, names a code nothing
+ * registered, or carries fields that do not decode.
+ *
+ * Never throws and never fails: whatever a peer sends, the caller gets a
+ * failure it can branch on.
+ *
+ * @param status the HTTP status the body arrived with, kept on a
+ *   `ProtocolFailure` so the caller still knows what the peer meant.
+ */ export const decodeProblem = (body, status)=>{
+    const protocol = (reason)=>new ProtocolFailure(_extends({
+            reason
+        }, status === undefined ? {} : {
+            upstreamStatus: status
+        }));
+    if (!isRecord(body) || typeof body['code'] !== 'string') return protocol('the error body is not a problem');
+    const registered = lookupFailure(body['code']);
+    if (registered === undefined) return protocol(`the problem names an unknown code '${body['code']}'`);
+    const decoded = Schema.decodeUnknownExit(registered.failureClass)(_extends({}, body, {
+        _tag: registered.tag
+    }));
+    return Exit.isSuccess(decoded) ? decoded.value : protocol(`the fields of '${body['code']}' do not decode`);
+};
+
+//# sourceMappingURL=problem.js.map

package/dist/failure/problem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/failure/problem.ts"],"sourcesContent":["import { Exit, Schema } from 'effect';\n\nimport {\n  defaultStatus,\n  type EntifixFailure,\n  FAILURE_CATEGORIES,\n} from './failure.js';\nimport { ProtocolFailure } from './generic.js';\nimport { failureTypeUri, lookupFailure } from './registry.js';\n\n/** The content type every error answer carries (RFC 9457). */\nexport const PROBLEM_CONTENT_TYPE = 'application/problem+json';\n\n/**\n * The envelope of an RFC 9457 problem, with entifix's members beside the\n * standard ones. `code` is top-level because it is what a client translates;\n * the failure's own fields ride as extension members.\n */\nexport const Problem = Schema.Struct({\n  type: Schema.String,\n  title: Schema.String,\n  status: Schema.Number,\n  code: Schema.String,\n  category: Schema.Literals(FAILURE_CATEGORIES),\n  detail: Schema.optionalKey(Schema.String),\n  instance: Schema.optionalKey(Schema.String),\n  traceId: Schema.optionalKey(Schema.String),\n});\n\n/** A problem body: the envelope plus the failure's own fields. */\nexport type Problem = typeof Problem.Type & Readonly<Record<string, unknown>>;\n\nexport interface ProblemOptions {\n  /** The status to answer with; the category's default when absent. */\n  readonly status?: number;\n  readonly traceId?: string;\n  /** The request path the failure answers. */\n  readonly instance?: string;\n}\n\n/**\n * The failure's own fields, encoded by the class that registered its code.\n *\n * ⚠️ Encoded through the **registered** class, not the instance's\n * constructor, so a failure decoded elsewhere encodes the same way. A failure\n * whose code nothing registered — impossible through the definers — encodes\n * with no fields rather than leaking whatever it carries.\n */\nconst encodedFields = (\n  failure: EntifixFailure,\n): Readonly<Record<string, unknown>> => {\n  const registered = lookupFailure(failure.code);\n  if (registered === undefined) return {};\n  const encoded = Schema.encodeUnknownExit(\n    registered.failureClass as unknown as Schema.Codec<unknown, unknown>,\n  )(failure);\n  if (Exit.isFailure(encoded)) return {};\n  const { _tag: _ignored, ...fields } = encoded.value as Record<\n    string,\n    unknown\n  >;\n  return fields;\n};\n\n/**\n * The problem body a failure answers with.\n *\n * `detail` is the failure's `message` when it has one, and is never\n * `String(error)`: a failure's message is written by its author for a reader,\n * a defect's text is not, and a defect never reaches this function.\n */\nexport const problemOf = (\n  failure: EntifixFailure,\n  options: ProblemOptions = {},\n): Problem => ({\n  ...encodedFields(failure),\n  type: failureTypeUri(failure.code),\n  title: failure._tag,\n  status: options.status ?? defaultStatus(failure.category),\n  code: failure.code,\n  category: failure.category,\n  ...(failure.message === '' ? {} : { detail: failure.message }),\n  ...(options.instance === undefined ? {} : { instance: options.instance }),\n  ...(options.traceId === undefined ? {} : { traceId: options.traceId }),\n});\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\n/**\n * The failure a problem body names, with its typed fields — or a\n * {@link ProtocolFailure} when the body is not a problem, names a code nothing\n * registered, or carries fields that do not decode.\n *\n * Never throws and never fails: whatever a peer sends, the caller gets a\n * failure it can branch on.\n *\n * @param status the HTTP status the body arrived with, kept on a\n *   `ProtocolFailure` so the caller still knows what the peer meant.\n */\nexport const decodeProblem = (\n  body: unknown,\n  status?: number,\n): EntifixFailure => {\n  const protocol = (reason: string) =>\n    new ProtocolFailure({\n      reason,\n      ...(status === undefined ? {} : { upstreamStatus: status }),\n    });\n\n  if (!isRecord(body) || typeof body['code'] !== 'string')\n    return protocol('the error body is not a problem');\n\n  const registered = lookupFailure(body['code']);\n  if (registered === undefined)\n    return protocol(`the problem names an unknown code '${body['code']}'`);\n\n  const decoded = Schema.decodeUnknownExit(\n    registered.failureClass as unknown as Schema.Codec<unknown, unknown>,\n  )({ ...body, _tag: registered.tag });\n\n  return Exit.isSuccess(decoded)\n    ? (decoded.value as EntifixFailure)\n    : protocol(`the fields of '${body['code']}' do not decode`);\n};\n"],"names":["Exit","Schema","defaultStatus","FAILURE_CATEGORIES","ProtocolFailure","failureTypeUri","lookupFailure","PROBLEM_CONTENT_TYPE","Problem","Struct","type","String","title","status","Number","code","category","Literals","detail","optionalKey","instance","traceId","encodedFields","failure","registered","undefined","encoded","encodeUnknownExit","failureClass","isFailure","value","_tag","_ignored","fields","problemOf","options","message","isRecord","Array","isArray","decodeProblem","body","protocol","reason","upstreamStatus","decoded","decodeUnknownExit","tag","isSuccess"],"mappings":";;AAAA,SAASA,IAAI,EAAEC,MAAM,QAAQ,SAAS;AAEtC,SACEC,aAAa,EAEbC,kBAAkB,QACb,eAAe;AACtB,SAASC,eAAe,QAAQ,eAAe;AAC/C,SAASC,cAAc,EAAEC,aAAa,QAAQ,gBAAgB;AAE9D,4DAA4D,GAC5D,OAAO,MAAMC,uBAAuB,2BAA2B;AAE/D;;;;CAIC,GACD,OAAO,MAAMC,UAAUP,OAAOQ,MAAM,CAAC;IACnCC,MAAMT,OAAOU,MAAM;IACnBC,OAAOX,OAAOU,MAAM;IACpBE,QAAQZ,OAAOa,MAAM;IACrBC,MAAMd,OAAOU,MAAM;IACnBK,UAAUf,OAAOgB,QAAQ,CAACd;IAC1Be,QAAQjB,OAAOkB,WAAW,CAAClB,OAAOU,MAAM;IACxCS,UAAUnB,OAAOkB,WAAW,CAAClB,OAAOU,MAAM;IAC1CU,SAASpB,OAAOkB,WAAW,CAAClB,OAAOU,MAAM;AAC3C,GAAG;AAaH;;;;;;;CAOC,GACD,MAAMW,gBAAgB,CACpBC;IAEA,MAAMC,aAAalB,cAAciB,QAAQR,IAAI;IAC7C,IAAIS,eAAeC,WAAW,OAAO,CAAC;IACtC,MAAMC,UAAUzB,OAAO0B,iBAAiB,CACtCH,WAAWI,YAAY,EACvBL;IACF,IAAIvB,KAAK6B,SAAS,CAACH,UAAU,OAAO,CAAC;IACrC,MAAsCA,iBAAAA,QAAQI,KAAK,EAA7C,EAAEC,MAAMC,QAAQ,EAAa,GAAGN,gBAAXO,0CAAWP;;;IAItC,OAAOO;AACT;AAEA;;;;;;CAMC,GACD,OAAO,MAAMC,YAAY,CACvBX,SACAY,UAA0B,CAAC,CAAC;QAKpBA;WAJK,aACVb,cAAcC;QACjBb,MAAML,eAAekB,QAAQR,IAAI;QACjCH,OAAOW,QAAQQ,IAAI;QACnBlB,MAAM,GAAEsB,kBAAAA,QAAQtB,MAAM,YAAdsB,kBAAkBjC,cAAcqB,QAAQP,QAAQ;QACxDD,MAAMQ,QAAQR,IAAI;QAClBC,UAAUO,QAAQP,QAAQ;OACtBO,QAAQa,OAAO,KAAK,KAAK,CAAC,IAAI;QAAElB,QAAQK,QAAQa,OAAO;IAAC,GACxDD,QAAQf,QAAQ,KAAKK,YAAY,CAAC,IAAI;QAAEL,UAAUe,QAAQf,QAAQ;IAAC,GACnEe,QAAQd,OAAO,KAAKI,YAAY,CAAC,IAAI;QAAEJ,SAASc,QAAQd,OAAO;IAAC;EACnE;AAEH,MAAMgB,WAAW,CAACP,QAChB,OAAOA,UAAU,YAAYA,UAAU,QAAQ,CAACQ,MAAMC,OAAO,CAACT;AAEhE;;;;;;;;;;CAUC,GACD,OAAO,MAAMU,gBAAgB,CAC3BC,MACA5B;IAEA,MAAM6B,WAAW,CAACC,SAChB,IAAIvC,gBAAgB;YAClBuC;WACI9B,WAAWY,YAAY,CAAC,IAAI;YAAEmB,gBAAgB/B;QAAO;IAG7D,IAAI,CAACwB,SAASI,SAAS,OAAOA,IAAI,CAAC,OAAO,KAAK,UAC7C,OAAOC,SAAS;IAElB,MAAMlB,aAAalB,cAAcmC,IAAI,CAAC,OAAO;IAC7C,IAAIjB,eAAeC,WACjB,OAAOiB,SAAS,CAAC,mCAAmC,EAAED,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAEvE,MAAMI,UAAU5C,OAAO6C,iBAAiB,CACtCtB,WAAWI,YAAY,EACvB,aAAKa;QAAMV,MAAMP,WAAWuB,GAAG;;IAEjC,OAAO/C,KAAKgD,SAAS,CAACH,WACjBA,QAAQf,KAAK,GACdY,SAAS,CAAC,eAAe,EAAED,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC;AAC9D,EAAE"}

package/dist/failure/registry.d.ts

@@ -0,0 +1,28 @@
+import type { FailureCategory, FailureClass, FailureFamily } from './failure.js';
+/** One registered failure: what a wire `code` decodes back into. */
+export interface RegisteredFailure {
+    readonly code: string;
+    readonly tag: string;
+    readonly category: FailureCategory;
+    readonly family: FailureFamily;
+    /** The RFC 9457 `type` URI. */
+    readonly type: string;
+    readonly failureClass: FailureClass;
+}
+/** The RFC 9457 `type` a code answers with. */
+export declare const failureTypeUri: (code: string) => string;
+/**
+ * Record a failure's code. A code is permanent (AIP-193): it never changes
+ * meaning and is never reused, so a second **tag** claiming one throws here,
+ * at module load, rather than putting two meanings on one wire.
+ *
+ * The same tag registering the same code again replaces the entry. That is a
+ * module evaluated twice — a dev server's hot reload, a test re-importing —
+ * and refusing it would turn every reload into a boot failure.
+ */
+export declare const registerFailure: (entry: RegisteredFailure) => void;
+/** The failure a code names, if anything registered it. */
+export declare const lookupFailure: (code: string) => RegisteredFailure | undefined;
+/** Every registered failure, ordered by code. */
+export declare const registeredFailures: () => readonly RegisteredFailure[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/failure/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/failure/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,aAAa,EACd,MAAM,cAAc,CAAC;AAEtB,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;CACrC;AAsBD,+CAA+C;AAC/C,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MACf,CAAC;AAEhC;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,iBAAiB,KAAG,IAS1D,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,iBAAiB,GAAG,SAC3C,CAAC;AAEvB,iDAAiD;AACjD,eAAO,MAAM,kBAAkB,QAAO,SAAS,iBAAiB,EACO,CAAC"}

package/dist/failure/registry.js

@@ -0,0 +1,36 @@
+/**
+ * The registry is shared through `globalThis` under a registered symbol, not
+ * held in a module-level `Map`.
+ *
+ * ⚠️ Two copies of `@entifix/core` in one process — a bundler that duplicated
+ * it, a consumer's own pin beside a dependency's — would otherwise hold two
+ * registries, and a failure defined against one would not decode through the
+ * other. One table per process is the property the bus relies on when it
+ * decodes a failure a second module instance defined.
+ */ const REGISTRY_KEY = Symbol.for('@entifix/core/failure-registry');
+const registry = ()=>{
+    var _holder, _REGISTRY_KEY, _;
+    const holder = globalThis;
+    (_ = (_holder = holder)[_REGISTRY_KEY = REGISTRY_KEY]) != null ? _ : _holder[_REGISTRY_KEY] = new Map();
+    return holder[REGISTRY_KEY];
+};
+/** The RFC 9457 `type` a code answers with. */ export const failureTypeUri = (code)=>`urn:entifix:failure:${code}`;
+/**
+ * Record a failure's code. A code is permanent (AIP-193): it never changes
+ * meaning and is never reused, so a second **tag** claiming one throws here,
+ * at module load, rather than putting two meanings on one wire.
+ *
+ * The same tag registering the same code again replaces the entry. That is a
+ * module evaluated twice — a dev server's hot reload, a test re-importing —
+ * and refusing it would turn every reload into a boot failure.
+ */ export const registerFailure = (entry)=>{
+    const existing = registry().get(entry.code);
+    if (existing !== undefined && existing.tag !== entry.tag) throw new Error(`failure code '${entry.code}' is already registered by '${existing.tag}', ` + `and '${entry.tag}' cannot claim it. A code is permanent and names ` + 'one failure: give this one its own.');
+    registry().set(entry.code, entry);
+};
+/** The failure a code names, if anything registered it. */ export const lookupFailure = (code)=>registry().get(code);
+/** Every registered failure, ordered by code. */ export const registeredFailures = ()=>[
+        ...registry().values()
+    ].sort((a, b)=>a.code.localeCompare(b.code));
+
+//# sourceMappingURL=registry.js.map

package/dist/failure/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/failure/registry.ts"],"sourcesContent":["import type {\n  FailureCategory,\n  FailureClass,\n  FailureFamily,\n} from './failure.js';\n\n/** One registered failure: what a wire `code` decodes back into. */\nexport interface RegisteredFailure {\n  readonly code: string;\n  readonly tag: string;\n  readonly category: FailureCategory;\n  readonly family: FailureFamily;\n  /** The RFC 9457 `type` URI. */\n  readonly type: string;\n  readonly failureClass: FailureClass;\n}\n\n/**\n * The registry is shared through `globalThis` under a registered symbol, not\n * held in a module-level `Map`.\n *\n * ⚠️ Two copies of `@entifix/core` in one process — a bundler that duplicated\n * it, a consumer's own pin beside a dependency's — would otherwise hold two\n * registries, and a failure defined against one would not decode through the\n * other. One table per process is the property the bus relies on when it\n * decodes a failure a second module instance defined.\n */\nconst REGISTRY_KEY = Symbol.for('@entifix/core/failure-registry');\n\ntype Registry = Map<string, RegisteredFailure>;\n\nconst registry = (): Registry => {\n  const holder = globalThis as { [REGISTRY_KEY]?: Registry };\n  holder[REGISTRY_KEY] ??= new Map();\n  return holder[REGISTRY_KEY];\n};\n\n/** The RFC 9457 `type` a code answers with. */\nexport const failureTypeUri = (code: string): string =>\n  `urn:entifix:failure:${code}`;\n\n/**\n * Record a failure's code. A code is permanent (AIP-193): it never changes\n * meaning and is never reused, so a second **tag** claiming one throws here,\n * at module load, rather than putting two meanings on one wire.\n *\n * The same tag registering the same code again replaces the entry. That is a\n * module evaluated twice — a dev server's hot reload, a test re-importing —\n * and refusing it would turn every reload into a boot failure.\n */\nexport const registerFailure = (entry: RegisteredFailure): void => {\n  const existing = registry().get(entry.code);\n  if (existing !== undefined && existing.tag !== entry.tag)\n    throw new Error(\n      `failure code '${entry.code}' is already registered by '${existing.tag}', ` +\n        `and '${entry.tag}' cannot claim it. A code is permanent and names ` +\n        'one failure: give this one its own.',\n    );\n  registry().set(entry.code, entry);\n};\n\n/** The failure a code names, if anything registered it. */\nexport const lookupFailure = (code: string): RegisteredFailure | undefined =>\n  registry().get(code);\n\n/** Every registered failure, ordered by code. */\nexport const registeredFailures = (): readonly RegisteredFailure[] =>\n  [...registry().values()].sort((a, b) => a.code.localeCompare(b.code));\n"],"names":["REGISTRY_KEY","Symbol","for","registry","holder","globalThis","Map","failureTypeUri","code","registerFailure","entry","existing","get","undefined","tag","Error","set","lookupFailure","registeredFailures","values","sort","a","b","localeCompare"],"mappings":"AAiBA;;;;;;;;;CASC,GACD,MAAMA,eAAeC,OAAOC,GAAG,CAAC;AAIhC,MAAMC,WAAW;QAEfC,SAAOJ,eAAPI;IADA,MAAMA,SAASC;KACfD,IAAAA,CAAAA,UAAAA,OAAM,CAACJ,gBAAAA,aAAa,YAApBI,IAAAA,OAAM,CAACJ,cAAa,GAAK,IAAIM;IAC7B,OAAOF,MAAM,CAACJ,aAAa;AAC7B;AAEA,6CAA6C,GAC7C,OAAO,MAAMO,iBAAiB,CAACC,OAC7B,CAAC,oBAAoB,EAAEA,MAAM,CAAC;AAEhC;;;;;;;;CAQC,GACD,OAAO,MAAMC,kBAAkB,CAACC;IAC9B,MAAMC,WAAWR,WAAWS,GAAG,CAACF,MAAMF,IAAI;IAC1C,IAAIG,aAAaE,aAAaF,SAASG,GAAG,KAAKJ,MAAMI,GAAG,EACtD,MAAM,IAAIC,MACR,CAAC,cAAc,EAAEL,MAAMF,IAAI,CAAC,4BAA4B,EAAEG,SAASG,GAAG,CAAC,GAAG,CAAC,GACzE,CAAC,KAAK,EAAEJ,MAAMI,GAAG,CAAC,iDAAiD,CAAC,GACpE;IAENX,WAAWa,GAAG,CAACN,MAAMF,IAAI,EAAEE;AAC7B,EAAE;AAEF,yDAAyD,GACzD,OAAO,MAAMO,gBAAgB,CAACT,OAC5BL,WAAWS,GAAG,CAACJ,MAAM;AAEvB,+CAA+C,GAC/C,OAAO,MAAMU,qBAAqB,IAChC;WAAIf,WAAWgB,MAAM;KAAG,CAACC,IAAI,CAAC,CAACC,GAAGC,IAAMD,EAAEb,IAAI,CAACe,aAAa,CAACD,EAAEd,IAAI,GAAG"}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './base-entities/configuration-client/index.js';
 export * from './base-entities/entifix-error/index.js';
 export * from './command-palette/index.js';
+export * from './deadline/deadline.js';
 export * from './entity-definition/decorators/accessor/index.js';
 export * from './entity-definition/decorators/entity/index.js';
 export * from './entity-definition/decorators/method/index.js';
@@ -22,6 +23,7 @@ export * from './entity-definition/reconstruct/index.js';
 export * from './entity-definition/serializer/index.js';
 export * from './entity-definition/validate/index.js';
 export * from './envelope/index.js';
+export * from './failure/index.js';
 export * from './hierarchy/index.js';
 export * from './http/session-cookies.js';
 export * from './i18n/format.js';