@entifix/core 0.8.0 → 0.10.0

package/dist/failure/generic.d.ts

@@ -0,0 +1,141 @@
+import { Schema } from 'effect';
+/**
+ * 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 declare const FieldProblem: Schema.Struct<{
+    readonly pointer: Schema.String;
+    readonly detail: Schema.String;
+    readonly code: Schema.String;
+}>;
+export type FieldProblem = typeof FieldProblem.Type;
+declare const Invalid_base: Schema.Class<Invalid, Schema.TaggedStruct<"Invalid", {
+    readonly errors: Schema.$Array<Schema.Struct<{
+        readonly pointer: Schema.String;
+        readonly detail: Schema.String;
+        readonly code: Schema.String;
+    }>>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"invalid", "invalid">>;
+/** The request breaks rules on its own; every broken one is listed. */
+export declare class Invalid extends Invalid_base {
+}
+declare const InvalidQuery_base: Schema.Class<InvalidQuery, Schema.TaggedStruct<"InvalidQuery", {
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"invalidQuery", "invalid">>;
+/** A list, filter or sort the query language cannot accept. */
+export declare class InvalidQuery extends InvalidQuery_base {
+}
+declare const InvalidEnvelope_base: Schema.Class<InvalidEnvelope, Schema.TaggedStruct<"InvalidEnvelope", {
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"invalidEnvelope", "invalid">>;
+/**
+ * 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 declare class InvalidEnvelope extends InvalidEnvelope_base {
+}
+declare const Unauthenticated_base: Schema.Class<Unauthenticated, Schema.TaggedStruct<"Unauthenticated", Record<never, never>>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"unauthenticated", "unauthenticated">>;
+/** No credential, or one that does not verify. */
+export declare class Unauthenticated extends Unauthenticated_base {
+}
+declare const Forbidden_base: Schema.Class<Forbidden, Schema.TaggedStruct<"Forbidden", {
+    readonly permission: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"forbidden", "forbidden">>;
+/** A verified caller without the grant. */
+export declare class Forbidden extends Forbidden_base {
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
+    readonly entity: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"notFound", "notFound">>;
+/** The addressed record does not exist. */
+export declare class NotFound extends NotFound_base {
+}
+declare const DuplicateKey_base: Schema.Class<DuplicateKey, Schema.TaggedStruct<"DuplicateKey", {
+    readonly key: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"duplicateKey", "conflict">>;
+/** A write that would duplicate a value the store declares unique. */
+export declare class DuplicateKey extends DuplicateKey_base {
+}
+declare const Declined_base: Schema.Class<Declined, Schema.TaggedStruct<"Declined", {
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"declined", "declined">>;
+/** A third party, or a rule over other records, said no. */
+export declare class Declined extends Declined_base {
+}
+declare const Contention_base: Schema.Class<Contention, Schema.TaggedStruct<"Contention", Record<never, never>>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"contention", "contention">>;
+/** Lost a race that a retry can win — a claim taken, a transaction aborted. */
+export declare class Contention extends Contention_base {
+}
+declare const Overloaded_base: Schema.Class<Overloaded, Schema.TaggedStruct<"Overloaded", {
+    readonly retryAfterSeconds: Schema.optionalKey<Schema.Number>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"overloaded", "exhausted">>;
+/** The dependency asked for less load. Stops retries wherever it appears. */
+export declare class Overloaded extends Overloaded_base {
+}
+declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"Unavailable", {
+    readonly dependency: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"unavailable", "unavailable">>;
+/** A dependency could not be reached. */
+export declare class Unavailable extends Unavailable_base {
+}
+declare const UpstreamUnavailable_base: Schema.Class<UpstreamUnavailable, Schema.TaggedStruct<"UpstreamUnavailable", {
+    readonly upstream: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"upstreamUnavailable", "unavailable">>;
+/** The service a proxy forwards to could not be reached. */
+export declare class UpstreamUnavailable extends UpstreamUnavailable_base {
+}
+declare const Timeout_base: Schema.Class<Timeout, Schema.TaggedStruct<"Timeout", {
+    readonly dependency: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"timeout", "timeout">>;
+/** A dependency did not answer in time. */
+export declare class Timeout extends Timeout_base {
+}
+declare const ProtocolFailure_base: Schema.Class<ProtocolFailure, Schema.TaggedStruct<"ProtocolFailure", {
+    readonly reason: Schema.String;
+    readonly upstreamStatus: Schema.optionalKey<Schema.Number>;
+}>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"protocol", "protocol">>;
+/**
+ * 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 declare class ProtocolFailure extends ProtocolFailure_base {
+}
+declare const Internal_base: Schema.Class<Internal, Schema.TaggedStruct<"Internal", Record<never, never>>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"internal", "internal">>;
+/** A bug, surfaced as a value. Never carries the bug's text onto a wire. */
+export declare class Internal extends Internal_base {
+}
+declare const IdempotencyKeyMissing_base: Schema.Class<IdempotencyKeyMissing, Schema.TaggedStruct<"IdempotencyKeyMissing", Record<never, never>>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"idempotencyKeyMissing", "invalid">>;
+/** An idempotent route was called without its `Idempotency-Key`. */
+export declare class IdempotencyKeyMissing extends IdempotencyKeyMissing_base {
+}
+declare const IdempotencyKeyReused_base: Schema.Class<IdempotencyKeyReused, Schema.TaggedStruct<"IdempotencyKeyReused", Record<never, never>>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"idempotencyKeyReused", "declined">>;
+/** One `Idempotency-Key` arrived with two different payloads. */
+export declare class IdempotencyKeyReused extends IdempotencyKeyReused_base {
+}
+declare const IdempotencyKeyInFlight_base: Schema.Class<IdempotencyKeyInFlight, Schema.TaggedStruct<"IdempotencyKeyInFlight", Record<never, never>>, import("effect/Cause").YieldableError & import("./failure.js").FailureFacts<"idempotencyKeyInFlight", "contention">>;
+/** The first request under this `Idempotency-Key` has not finished. */
+export declare class IdempotencyKeyInFlight extends IdempotencyKeyInFlight_base {
+}
+/**
+ * What a store adapter fails with — a datastore, a cache, a bus: the value it
+ * guarded already exists, someone else got there first, it could not be
+ * reached, it did not answer in time, or it answered something unreadable.
+ * A port that talks to storage names this as its failure.
+ */
+export type StoreFailure = DuplicateKey | Contention | Unavailable | Timeout | ProtocolFailure;
+/**
+ * The technical part of {@link StoreFailure}: the store failing to answer, as
+ * opposed to answering no. A unit of work rolls back and surfaces these; a
+ * business failure — a `DuplicateKey` included — is its abort.
+ */
+export type StoreFault = Exclude<StoreFailure, DuplicateKey>;
+/** Whether `value` is a {@link StoreFault}, read by tag. */
+export declare const isStoreFault: (value: unknown) => value is StoreFault;
+export {};
+//# sourceMappingURL=generic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/failure/generic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC;;;;;;GAMG;AAEH,kFAAkF;AAClF,eAAO,MAAM,YAAY;;;;EAIvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAC;;;;;;;;AAEpD,uEAAuE;AACvE,qBAAa,OAAQ,SAAQ,YAI5B;CAAG;;;;AAEJ,+DAA+D;AAC/D,qBAAa,YAAa,SAAQ,iBAKjC;CAAG;;;;AAEJ;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,oBAOpC;CAAG;;AAEJ,kDAAkD;AAClD,qBAAa,eAAgB,SAAQ,oBAEqB;CAAG;;;;AAE7D,2CAA2C;AAC3C,qBAAa,SAAU,SAAQ,cAM9B;CAAG;;;;AAEJ,2CAA2C;AAC3C,qBAAa,QAAS,SAAQ,aAI7B;CAAG;;;;AAEJ,sEAAsE;AACtE,qBAAa,YAAa,SAAQ,iBAIjC;CAAG;;;;AAEJ,4DAA4D;AAC5D,qBAAa,QAAS,SAAQ,aAK7B;CAAG;;AAEJ,+EAA+E;AAC/E,qBAAa,UAAW,SAAQ,eAG/B;CAAG;;;;AAEJ,6EAA6E;AAC7E,qBAAa,UAAW,SAAQ,eAI/B;CAAG;;;;AAEJ,yCAAyC;AACzC,qBAAa,WAAY,SAAQ,gBAIhC;CAAG;;;;AAEJ,4DAA4D;AAC5D,qBAAa,mBAAoB,SAAQ,wBAIvC;CAAG;;;;AAEL,2CAA2C;AAC3C,qBAAa,OAAQ,SAAQ,YAI5B;CAAG;;;;;AAEJ;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,oBAUpC;CAAG;;AAEJ,4EAA4E;AAC5E,qBAAa,QAAS,SAAQ,aAG7B;CAAG;;AAEJ,oEAAoE;AACpE,qBAAa,qBAAsB,SAAQ,0BAEiC;CAAG;;AAE/E,iEAAiE;AACjE,qBAAa,oBAAqB,SAAQ,yBAE+B;CAAG;;AAE5E,uEAAuE;AACvE,qBAAa,sBAAuB,SAAQ,2BAK3C;CAAG;AAEJ;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACtB,YAAY,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO,GAAG,eAAe,CAAC;AAEtE;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;AAS7D,4DAA4D;AAC5D,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,UAGsB,CAAC"}

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":"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"}

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"}