@entifix/business 0.1.0-0

package/dist/use-case/delete/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/use-case/delete/index.ts"],"sourcesContent":["export * from './delete.uc.js';\n"],"names":[],"mappings":"AAAA,cAAc,iBAAiB"}

package/dist/use-case/get/get.uc.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from '@entifix/core';
+import { Effect } from 'effect';
+import { EntityRepositoryTag } from '../../repository/entity.repository.js';
+import { EntityIdTag } from '../../repository/entity-mixins.repository.js';
+/**
+ * Reads a single entity by id.
+ *
+ * The factory's type parameter is what makes the result usable without a cast
+ * at the call site — {@link EntityIdTag} carries no entity type of its own.
+ */
+export declare function getUCFactory<TEntity extends Entity>(): Effect.Effect<TEntity, import("@entifix/core").EntifixError, import("../../index.js").ConfigurationRepositoryTag | EntityRepositoryTag | EntityIdTag>;
+//# sourceMappingURL=get.uc.d.ts.map

package/dist/use-case/get/get.uc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.uc.d.ts","sourceRoot":"","sources":["../../../src/use-case/get/get.uc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,8CAA8C,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,SAAS,MAAM,2JASlD"}

package/dist/use-case/get/get.uc.js

@@ -0,0 +1,18 @@
+import { Effect } from 'effect';
+import { EntityRepositoryTag } from '../../repository/entity.repository.js';
+import { EntityIdTag } from '../../repository/entity-mixins.repository.js';
+/**
+ * Reads a single entity by id.
+ *
+ * The factory's type parameter is what makes the result usable without a cast
+ * at the call site — {@link EntityIdTag} carries no entity type of its own.
+ */ export function getUCFactory() {
+    return Effect.gen(function*() {
+        const entityRepository = yield* EntityRepositoryTag;
+        const entityId = yield* EntityIdTag;
+        const result = yield* entityRepository.get(entityId);
+        return result;
+    });
+}
+
+//# sourceMappingURL=get.uc.js.map

package/dist/use-case/get/get.uc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/use-case/get/get.uc.ts"],"sourcesContent":["import { Entity } from '@entifix/core';\nimport { Effect } from 'effect';\n\nimport { EntityRepositoryTag } from '../../repository/entity.repository.js';\nimport { EntityIdTag } from '../../repository/entity-mixins.repository.js';\n\n/**\n * Reads a single entity by id.\n *\n * The factory's type parameter is what makes the result usable without a cast\n * at the call site — {@link EntityIdTag} carries no entity type of its own.\n */\nexport function getUCFactory<TEntity extends Entity>() {\n  return Effect.gen(function* () {\n    const entityRepository = yield* EntityRepositoryTag;\n    const entityId = yield* EntityIdTag;\n\n    const result = yield* entityRepository.get<TEntity>(entityId);\n\n    return result;\n  });\n}\n"],"names":["Effect","EntityRepositoryTag","EntityIdTag","getUCFactory","gen","entityRepository","entityId","result","get"],"mappings":"AACA,SAASA,MAAM,QAAQ,SAAS;AAEhC,SAASC,mBAAmB,QAAQ,wCAAwC;AAC5E,SAASC,WAAW,QAAQ,+CAA+C;AAE3E;;;;;CAKC,GACD,OAAO,SAASC;IACd,OAAOH,OAAOI,GAAG,CAAC;QAChB,MAAMC,mBAAmB,OAAOJ;QAChC,MAAMK,WAAW,OAAOJ;QAExB,MAAMK,SAAS,OAAOF,iBAAiBG,GAAG,CAAUF;QAEpD,OAAOC;IACT;AACF"}

package/dist/use-case/get/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get.uc.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/use-case/get/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/use-case/get/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/use-case/get/index.js

@@ -0,0 +1,3 @@
+export * from './get.uc.js';
+
+//# sourceMappingURL=index.js.map

package/dist/use-case/get/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/use-case/get/index.ts"],"sourcesContent":["export * from './get.uc.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc"}

package/dist/use-case/load/index.d.ts

@@ -0,0 +1,2 @@
+export * from './load.uc.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/use-case/load/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/use-case/load/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/use-case/load/index.js

@@ -0,0 +1,3 @@
+export * from './load.uc.js';
+
+//# sourceMappingURL=index.js.map

package/dist/use-case/load/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/use-case/load/index.ts"],"sourcesContent":["export * from './load.uc.js';\n"],"names":[],"mappings":"AAAA,cAAc,eAAe"}

package/dist/use-case/load/load.uc.d.ts

@@ -0,0 +1,6 @@
+import { Entity } from '@entifix/core';
+import { Effect } from 'effect';
+import { EntityRepositoryTag } from '../../repository/entity.repository.js';
+import { EntityLoadRequestTag } from '../../repository/entity-mixins.repository.js';
+export declare function loadUCFactory<TEntity extends Entity>(): Effect.Effect<import("@entifix/core").EntityPage<TEntity>, import("@entifix/core").EntifixError, import("../../index.js").ConfigurationRepositoryTag | EntityRepositoryTag | EntityLoadRequestTag>;
+//# sourceMappingURL=load.uc.d.ts.map

package/dist/use-case/load/load.uc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.uc.d.ts","sourceRoot":"","sources":["../../../src/use-case/load/load.uc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AAEpF,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,wMAenD"}

package/dist/use-case/load/load.uc.js

@@ -0,0 +1,16 @@
+import { Effect } from 'effect';
+import { EntityRepositoryTag } from '../../repository/entity.repository.js';
+import { EntityLoadRequestTag } from '../../repository/entity-mixins.repository.js';
+export function loadUCFactory() {
+    return Effect.gen(function*() {
+        const entityRepository = yield* EntityRepositoryTag;
+        const entityLoadRequest = yield* EntityLoadRequestTag;
+        // Type assertion to ensure the load request is of the correct entity type
+        // This is necessary because the EntityLoadRequestTag does not carry generic type information
+        const typedEntityLoadRequest = entityLoadRequest;
+        const result = yield* entityRepository.load(typedEntityLoadRequest);
+        return result;
+    });
+}
+
+//# sourceMappingURL=load.uc.js.map

package/dist/use-case/load/load.uc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/use-case/load/load.uc.ts"],"sourcesContent":["import { Entity, EntityLoadRequest } from '@entifix/core';\nimport { Effect } from 'effect';\n\nimport { EntityRepositoryTag } from '../../repository/entity.repository.js';\nimport { EntityLoadRequestTag } from '../../repository/entity-mixins.repository.js';\n\nexport function loadUCFactory<TEntity extends Entity>() {\n  return Effect.gen(function* () {\n    const entityRepository = yield* EntityRepositoryTag;\n    const entityLoadRequest = yield* EntityLoadRequestTag;\n\n    // Type assertion to ensure the load request is of the correct entity type\n    // This is necessary because the EntityLoadRequestTag does not carry generic type information\n    const typedEntityLoadRequest =\n      entityLoadRequest as unknown as EntityLoadRequest<TEntity>;\n\n    const result = yield* entityRepository.load<TEntity>(\n      typedEntityLoadRequest,\n    );\n    return result;\n  });\n}\n"],"names":["Effect","EntityRepositoryTag","EntityLoadRequestTag","loadUCFactory","gen","entityRepository","entityLoadRequest","typedEntityLoadRequest","result","load"],"mappings":"AACA,SAASA,MAAM,QAAQ,SAAS;AAEhC,SAASC,mBAAmB,QAAQ,wCAAwC;AAC5E,SAASC,oBAAoB,QAAQ,+CAA+C;AAEpF,OAAO,SAASC;IACd,OAAOH,OAAOI,GAAG,CAAC;QAChB,MAAMC,mBAAmB,OAAOJ;QAChC,MAAMK,oBAAoB,OAAOJ;QAEjC,0EAA0E;QAC1E,6FAA6F;QAC7F,MAAMK,yBACJD;QAEF,MAAME,SAAS,OAAOH,iBAAiBI,IAAI,CACzCF;QAEF,OAAOC;IACT;AACF"}

package/dist/use-case/save/index.d.ts

@@ -0,0 +1,2 @@
+export * from './save.uc.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/use-case/save/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/use-case/save/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/use-case/save/index.js

@@ -0,0 +1,3 @@
+export * from './save.uc.js';
+
+//# sourceMappingURL=index.js.map

package/dist/use-case/save/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/use-case/save/index.ts"],"sourcesContent":["export * from './save.uc.js';\n"],"names":[],"mappings":"AAAA,cAAc,eAAe"}

package/dist/use-case/save/save.uc.d.ts

@@ -0,0 +1,16 @@
+import { Entity } from '@entifix/core';
+import { Effect } from 'effect';
+import { EntityRepositoryTag } from '../../repository/entity.repository.js';
+import { EntityTag } from '../../repository/entity-mixins.repository.js';
+/**
+ * Persists an entity and returns whatever the repository considers the stored
+ * truth — which is not necessarily the input: a create round-trips through the
+ * adapter's id generation, so the returned entity is the one callers should
+ * render.
+ *
+ * Like {@link loadUCFactory}, this yields its inputs from context rather than
+ * taking them as arguments, so the same use-case saves over REST on the web and
+ * over Mongo on a backend.
+ */
+export declare function saveUCFactory<TEntity extends Entity>(): Effect.Effect<TEntity, [import("effect/Utils").YieldWrap<import("effect/Context").Tag<EntityRepositoryTag, import("../../index.js").EntityRepository>> | import("effect/Utils").YieldWrap<import("effect/Context").Tag<EntityTag, Entity>> | import("effect/Utils").YieldWrap<Effect.Effect<TEntity, import("@entifix/core").EntifixError, import("../../index.js").ConfigurationRepositoryTag>>] extends [import("effect/Utils").YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E : never, [import("effect/Utils").YieldWrap<import("effect/Context").Tag<EntityRepositoryTag, import("../../index.js").EntityRepository>> | import("effect/Utils").YieldWrap<import("effect/Context").Tag<EntityTag, Entity>> | import("effect/Utils").YieldWrap<Effect.Effect<TEntity, import("@entifix/core").EntifixError, import("../../index.js").ConfigurationRepositoryTag>>] extends [import("effect/Utils").YieldWrap<Effect.Effect<infer _A_1, infer _E, infer R>>] ? R : never>;
+//# sourceMappingURL=save.uc.d.ts.map

package/dist/use-case/save/save.uc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.uc.d.ts","sourceRoot":"","sources":["../../../src/use-case/save/save.uc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AAEzE;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,47BAWnD"}

package/dist/use-case/save/save.uc.js

@@ -0,0 +1,24 @@
+import { Effect } from 'effect';
+import { EntityRepositoryTag } from '../../repository/entity.repository.js';
+import { EntityTag } from '../../repository/entity-mixins.repository.js';
+/**
+ * Persists an entity and returns whatever the repository considers the stored
+ * truth — which is not necessarily the input: a create round-trips through the
+ * adapter's id generation, so the returned entity is the one callers should
+ * render.
+ *
+ * Like {@link loadUCFactory}, this yields its inputs from context rather than
+ * taking them as arguments, so the same use-case saves over REST on the web and
+ * over Mongo on a backend.
+ */ export function saveUCFactory() {
+    return Effect.gen(function*() {
+        const entityRepository = yield* EntityRepositoryTag;
+        const entity = yield* EntityTag;
+        // EntityTag is not generic, so it carries the base `Entity`; the caller
+        // states the concrete type through the factory's parameter.
+        const result = yield* entityRepository.save(entity);
+        return result;
+    });
+}
+
+//# sourceMappingURL=save.uc.js.map

package/dist/use-case/save/save.uc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/use-case/save/save.uc.ts"],"sourcesContent":["import { Entity } from '@entifix/core';\nimport { Effect } from 'effect';\n\nimport { EntityRepositoryTag } from '../../repository/entity.repository.js';\nimport { EntityTag } from '../../repository/entity-mixins.repository.js';\n\n/**\n * Persists an entity and returns whatever the repository considers the stored\n * truth — which is not necessarily the input: a create round-trips through the\n * adapter's id generation, so the returned entity is the one callers should\n * render.\n *\n * Like {@link loadUCFactory}, this yields its inputs from context rather than\n * taking them as arguments, so the same use-case saves over REST on the web and\n * over Mongo on a backend.\n */\nexport function saveUCFactory<TEntity extends Entity>() {\n  return Effect.gen(function* () {\n    const entityRepository = yield* EntityRepositoryTag;\n    const entity = yield* EntityTag;\n\n    // EntityTag is not generic, so it carries the base `Entity`; the caller\n    // states the concrete type through the factory's parameter.\n    const result = yield* entityRepository.save<TEntity>(entity as TEntity);\n\n    return result;\n  });\n}\n"],"names":["Effect","EntityRepositoryTag","EntityTag","saveUCFactory","gen","entityRepository","entity","result","save"],"mappings":"AACA,SAASA,MAAM,QAAQ,SAAS;AAEhC,SAASC,mBAAmB,QAAQ,wCAAwC;AAC5E,SAASC,SAAS,QAAQ,+CAA+C;AAEzE;;;;;;;;;CASC,GACD,OAAO,SAASC;IACd,OAAOH,OAAOI,GAAG,CAAC;QAChB,MAAMC,mBAAmB,OAAOJ;QAChC,MAAMK,SAAS,OAAOJ;QAEtB,wEAAwE;QACxE,4DAA4D;QAC5D,MAAMK,SAAS,OAAOF,iBAAiBG,IAAI,CAAUF;QAErD,OAAOC;IACT;AACF"}

package/dist/wiring/wiring-registry.d.ts

@@ -0,0 +1,74 @@
+import { Context, Effect, Layer } from 'effect';
+/**
+ * The queue shapes a subscriber may ask for (ADR 0030).
+ *
+ * Duplicated from `SubscriptionMode` in `@entifix/transactions` rather than
+ * imported: that package sits at `entifix:transactions`, **above** this one at
+ * `entifix:contract`, so the edge would point upward and the boundary rule fails
+ * the build on it. The same duplication exists in `tools/slices/src/types.ts`
+ * for the same reason, and both lists are pinned by a spec.
+ */
+export declare const BOUND_SUBSCRIPTION_MODES: readonly ["work", "broadcast"];
+export type BoundSubscriptionMode = (typeof BOUND_SUBSCRIPTION_MODES)[number];
+/**
+ * One subscription a running process **actually bound**, recorded by the bus
+ * adapter as `subscribe` runs.
+ *
+ * Observed rather than declared, which is the whole point: a document generated
+ * from `tools/slices/` would agree with `tools/slices/` by construction and
+ * catch nothing (ADR 0031). `queue` is the broker's own name for it, so someone
+ * looking at depth in the management UI can match the two up.
+ */
+export interface BoundSubscription {
+    /** The **subscribing** slice — never the emitter. See `Subscription.slice`. */
+    readonly slice: string;
+    readonly pattern: string;
+    readonly mode: BoundSubscriptionMode;
+    readonly queue: string;
+}
+/**
+ * What a process did with its bus, as opposed to what it can still reach.
+ *
+ * A sibling of `HealthRegistry` rather than part of it: a subscription is not a
+ * readiness fact — a bound queue says nothing about whether the broker is
+ * answering right now — and folding the two together would put entries in the
+ * readiness response that no probe can check.
+ *
+ * Both halves are cumulative and never cleared. `published` is a set of event
+ * **names** and nothing else: no payloads, no counts, no timestamps. Counts
+ * would be per-replica and un-alertable, which is the telemetry path ADR 0001
+ * already chose OTLP for.
+ */
+export interface WiringRegistry {
+    /** Called by the bus adapter once per binding, including after a reconnect. */
+    readonly recordSubscription: (bound: BoundSubscription) => Effect.Effect<void>;
+    /** Called by the bus adapter on every publish. Idempotent per name. */
+    readonly recordPublish: (eventName: string) => Effect.Effect<void>;
+    /** Every distinct binding, in the order it was first made. */
+    readonly subscriptions: Effect.Effect<readonly BoundSubscription[]>;
+    /** Every distinct event name emitted since boot, in first-seen order. */
+    readonly published: Effect.Effect<readonly string[]>;
+}
+declare const WiringRegistryTag_base: Context.TagClass<WiringRegistryTag, "WiringRegistryTag", WiringRegistry>;
+/**
+ * DI tag for the wiring registry.
+ *
+ * It lives here, in the contract layer, so `@entifix/amqp` can record
+ * into it without depending on a shell — the same placement, and the same
+ * reason, as {@link HealthRegistryTag}.
+ */
+export declare class WiringRegistryTag extends WiringRegistryTag_base {
+}
+/**
+ * Live registry over a `Ref`. Provide it **once** per service and share the
+ * instance (`Layer.provideMerge`), or the bus records into a registry the
+ * description route never reads.
+ *
+ * Both recorders deduplicate. A reconnect re-runs every consumer's setup
+ * against the new channel (`AmqpConnector.addConsumer`), so without it a broker
+ * restart would list the same binding twice; and a publisher emits the same
+ * event name continuously, so without it the list would grow without bound.
+ */
+export declare const WiringRegistryLayer: Layer.Layer<WiringRegistryTag>;
+export {};
+//# sourceMappingURL=wiring-registry.d.ts.map

package/dist/wiring/wiring-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wiring-registry.d.ts","sourceRoot":"","sources":["../../src/wiring/wiring-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAO,MAAM,QAAQ,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,gCAAiC,CAAC;AAEvE,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,kBAAkB,EAAE,CAC3B,KAAK,EAAE,iBAAiB,KACrB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACnE,8DAA8D;IAC9D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAAC;IACpE,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CACtD;;AAED;;;;;;GAMG;AACH,qBAAa,iBAAkB,SAAQ,sBAGpC;CAAG;AASN;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAuB9D,CAAC"}

package/dist/wiring/wiring-registry.js

@@ -0,0 +1,49 @@
+import { Context, Effect, Layer, Ref } from 'effect';
+/**
+ * The queue shapes a subscriber may ask for (ADR 0030).
+ *
+ * Duplicated from `SubscriptionMode` in `@entifix/transactions` rather than
+ * imported: that package sits at `entifix:transactions`, **above** this one at
+ * `entifix:contract`, so the edge would point upward and the boundary rule fails
+ * the build on it. The same duplication exists in `tools/slices/src/types.ts`
+ * for the same reason, and both lists are pinned by a spec.
+ */ export const BOUND_SUBSCRIPTION_MODES = [
+    'work',
+    'broadcast'
+];
+/**
+ * DI tag for the wiring registry.
+ *
+ * It lives here, in the contract layer, so `@entifix/amqp` can record
+ * into it without depending on a shell — the same placement, and the same
+ * reason, as {@link HealthRegistryTag}.
+ */ export class WiringRegistryTag extends Context.Tag('WiringRegistryTag')() {
+}
+/** Whether two bindings are the same binding. */ const same = (a, b)=>a.slice === b.slice && a.pattern === b.pattern && a.mode === b.mode && a.queue === b.queue;
+/**
+ * Live registry over a `Ref`. Provide it **once** per service and share the
+ * instance (`Layer.provideMerge`), or the bus records into a registry the
+ * description route never reads.
+ *
+ * Both recorders deduplicate. A reconnect re-runs every consumer's setup
+ * against the new channel (`AmqpConnector.addConsumer`), so without it a broker
+ * restart would list the same binding twice; and a publisher emits the same
+ * event name continuously, so without it the list would grow without bound.
+ */ export const WiringRegistryLayer = Layer.effect(WiringRegistryTag, Effect.gen(function*() {
+    const subscriptions = yield* Ref.make([]);
+    const published = yield* Ref.make([]);
+    return {
+        recordSubscription: (bound)=>Ref.update(subscriptions, (current)=>current.some((existing)=>same(existing, bound)) ? current : [
+                    ...current,
+                    bound
+                ]),
+        recordPublish: (eventName)=>Ref.update(published, (current)=>current.includes(eventName) ? current : [
+                    ...current,
+                    eventName
+                ]),
+        subscriptions: Ref.get(subscriptions),
+        published: Ref.get(published)
+    };
+}));
+
+//# sourceMappingURL=wiring-registry.js.map

package/dist/wiring/wiring-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wiring/wiring-registry.ts"],"sourcesContent":["import { Context, Effect, Layer, Ref } from 'effect';\n\n/**\n * The queue shapes a subscriber may ask for (ADR 0030).\n *\n * Duplicated from `SubscriptionMode` in `@entifix/transactions` rather than\n * imported: that package sits at `entifix:transactions`, **above** this one at\n * `entifix:contract`, so the edge would point upward and the boundary rule fails\n * the build on it. The same duplication exists in `tools/slices/src/types.ts`\n * for the same reason, and both lists are pinned by a spec.\n */\nexport const BOUND_SUBSCRIPTION_MODES = ['work', 'broadcast'] as const;\n\nexport type BoundSubscriptionMode = (typeof BOUND_SUBSCRIPTION_MODES)[number];\n\n/**\n * One subscription a running process **actually bound**, recorded by the bus\n * adapter as `subscribe` runs.\n *\n * Observed rather than declared, which is the whole point: a document generated\n * from `tools/slices/` would agree with `tools/slices/` by construction and\n * catch nothing (ADR 0031). `queue` is the broker's own name for it, so someone\n * looking at depth in the management UI can match the two up.\n */\nexport interface BoundSubscription {\n  /** The **subscribing** slice — never the emitter. See `Subscription.slice`. */\n  readonly slice: string;\n  readonly pattern: string;\n  readonly mode: BoundSubscriptionMode;\n  readonly queue: string;\n}\n\n/**\n * What a process did with its bus, as opposed to what it can still reach.\n *\n * A sibling of `HealthRegistry` rather than part of it: a subscription is not a\n * readiness fact — a bound queue says nothing about whether the broker is\n * answering right now — and folding the two together would put entries in the\n * readiness response that no probe can check.\n *\n * Both halves are cumulative and never cleared. `published` is a set of event\n * **names** and nothing else: no payloads, no counts, no timestamps. Counts\n * would be per-replica and un-alertable, which is the telemetry path ADR 0001\n * already chose OTLP for.\n */\nexport interface WiringRegistry {\n  /** Called by the bus adapter once per binding, including after a reconnect. */\n  readonly recordSubscription: (\n    bound: BoundSubscription,\n  ) => Effect.Effect<void>;\n  /** Called by the bus adapter on every publish. Idempotent per name. */\n  readonly recordPublish: (eventName: string) => Effect.Effect<void>;\n  /** Every distinct binding, in the order it was first made. */\n  readonly subscriptions: Effect.Effect<readonly BoundSubscription[]>;\n  /** Every distinct event name emitted since boot, in first-seen order. */\n  readonly published: Effect.Effect<readonly string[]>;\n}\n\n/**\n * DI tag for the wiring registry.\n *\n * It lives here, in the contract layer, so `@entifix/amqp` can record\n * into it without depending on a shell — the same placement, and the same\n * reason, as {@link HealthRegistryTag}.\n */\nexport class WiringRegistryTag extends Context.Tag('WiringRegistryTag')<\n  WiringRegistryTag,\n  WiringRegistry\n>() {}\n\n/** Whether two bindings are the same binding. */\nconst same = (a: BoundSubscription, b: BoundSubscription): boolean =>\n  a.slice === b.slice &&\n  a.pattern === b.pattern &&\n  a.mode === b.mode &&\n  a.queue === b.queue;\n\n/**\n * Live registry over a `Ref`. Provide it **once** per service and share the\n * instance (`Layer.provideMerge`), or the bus records into a registry the\n * description route never reads.\n *\n * Both recorders deduplicate. A reconnect re-runs every consumer's setup\n * against the new channel (`AmqpConnector.addConsumer`), so without it a broker\n * restart would list the same binding twice; and a publisher emits the same\n * event name continuously, so without it the list would grow without bound.\n */\nexport const WiringRegistryLayer: Layer.Layer<WiringRegistryTag> = Layer.effect(\n  WiringRegistryTag,\n  Effect.gen(function* () {\n    const subscriptions = yield* Ref.make<readonly BoundSubscription[]>([]);\n    const published = yield* Ref.make<readonly string[]>([]);\n\n    return {\n      recordSubscription: bound =>\n        Ref.update(subscriptions, current =>\n          current.some(existing => same(existing, bound))\n            ? current\n            : [...current, bound],\n        ),\n\n      recordPublish: eventName =>\n        Ref.update(published, current =>\n          current.includes(eventName) ? current : [...current, eventName],\n        ),\n\n      subscriptions: Ref.get(subscriptions),\n      published: Ref.get(published),\n    };\n  }),\n);\n"],"names":["Context","Effect","Layer","Ref","BOUND_SUBSCRIPTION_MODES","WiringRegistryTag","Tag","same","a","b","slice","pattern","mode","queue","WiringRegistryLayer","effect","gen","subscriptions","make","published","recordSubscription","bound","update","current","some","existing","recordPublish","eventName","includes","get"],"mappings":"AAAA,SAASA,OAAO,EAAEC,MAAM,EAAEC,KAAK,EAAEC,GAAG,QAAQ,SAAS;AAErD;;;;;;;;CAQC,GACD,OAAO,MAAMC,2BAA2B;IAAC;IAAQ;CAAY,CAAU;AA+CvE;;;;;;CAMC,GACD,OAAO,MAAMC,0BAA0BL,QAAQM,GAAG,CAAC;AAG9C;AAEL,+CAA+C,GAC/C,MAAMC,OAAO,CAACC,GAAsBC,IAClCD,EAAEE,KAAK,KAAKD,EAAEC,KAAK,IACnBF,EAAEG,OAAO,KAAKF,EAAEE,OAAO,IACvBH,EAAEI,IAAI,KAAKH,EAAEG,IAAI,IACjBJ,EAAEK,KAAK,KAAKJ,EAAEI,KAAK;AAErB;;;;;;;;;CASC,GACD,OAAO,MAAMC,sBAAsDZ,MAAMa,MAAM,CAC7EV,mBACAJ,OAAOe,GAAG,CAAC;IACT,MAAMC,gBAAgB,OAAOd,IAAIe,IAAI,CAA+B,EAAE;IACtE,MAAMC,YAAY,OAAOhB,IAAIe,IAAI,CAAoB,EAAE;IAEvD,OAAO;QACLE,oBAAoBC,CAAAA,QAClBlB,IAAImB,MAAM,CAACL,eAAeM,CAAAA,UACxBA,QAAQC,IAAI,CAACC,CAAAA,WAAYlB,KAAKkB,UAAUJ,UACpCE,UACA;uBAAIA;oBAASF;iBAAM;QAG3BK,eAAeC,CAAAA,YACbxB,IAAImB,MAAM,CAACH,WAAWI,CAAAA,UACpBA,QAAQK,QAAQ,CAACD,aAAaJ,UAAU;uBAAIA;oBAASI;iBAAU;QAGnEV,eAAed,IAAI0B,GAAG,CAACZ;QACvBE,WAAWhB,IAAI0B,GAAG,CAACV;IACrB;AACF,IACA"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@entifix/business",
+  "version": "0.1.0-0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/ts/business"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@entifix/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "nx": {
+    "tags": [
+      "layer:entifix",
+      "scope:shared",
+      "entifix:contract",
+      "tier:1"
+    ],
+    "sourceRoot": "packages/ts/business/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/ts/business/dist",
+          "main": "packages/ts/business/src/index.ts",
+          "tsConfig": "packages/ts/business/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.23",
+    "@entifix/core": "0.1.0-0"
+  },
+  "peerDependencies": {
+    "effect": ">=3.22 <4"
+  },
+  "devDependencies": {
+    "effect": "3.22.1"
+  }
+}