@entifix/service-shell 0.1.0-0

package/dist/redact-configuration.d.ts

@@ -0,0 +1,20 @@
+import { ConfigurationPlain } from '@entifix/core';
+/** Masks credentials embedded in a connection-string value, if present. */
+export declare const redactValue: (value: unknown) => unknown;
+/**
+ * Returns a copy of a {@link ConfigurationPlain} safe to expose from a service's
+ * **unauthenticated** `GET /api/config` introspection endpoint.
+ *
+ * Two rules, and the first one carries the weight:
+ *
+ * 1. Any item the configuration store flagged `isSecret` is blanked outright.
+ *    This is what keeps auth-service's RSA private key — a value that mints
+ *    `super-admin` tokens for anyone holding it — off a public endpoint. The
+ *    flag comes from the store's own `is_secret` column rather than from a
+ *    guess about the key's name, because a heuristic that misses once
+ *    publishes a signing key.
+ * 2. Connection-string credentials are masked even when unflagged, so a URI
+ *    someone forgot to flag still does not leak its password.
+ */
+export declare const redactConfiguration: (plain: ConfigurationPlain) => ConfigurationPlain;
+//# sourceMappingURL=redact-configuration.d.ts.map

package/dist/redact-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact-configuration.d.ts","sourceRoot":"","sources":["../src/redact-configuration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAMnD,2EAA2E;AAC3E,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,OAGlC,CAAC;AAKZ;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,kBAAkB,KACxB,kBAUF,CAAC"}

package/dist/redact-configuration.js

@@ -0,0 +1,34 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+// Matches the `user:password@` credential segment of a connection URI
+// (`scheme://user:pass@host...`) so it can be masked in diagnostic output.
+const CREDENTIALS_IN_URI = /^([a-z][a-z0-9+.-]*:\/\/)([^:@/]+):([^@/]+)@/i;
+/** Masks credentials embedded in a connection-string value, if present. */ export const redactValue = (value)=>typeof value === 'string' ? value.replace(CREDENTIALS_IN_URI, '$1***:***@') : value;
+/** What a secret's value is replaced with — its presence stays visible, its content does not. */ const REDACTED = '***';
+/**
+ * Returns a copy of a {@link ConfigurationPlain} safe to expose from a service's
+ * **unauthenticated** `GET /api/config` introspection endpoint.
+ *
+ * Two rules, and the first one carries the weight:
+ *
+ * 1. Any item the configuration store flagged `isSecret` is blanked outright.
+ *    This is what keeps auth-service's RSA private key — a value that mints
+ *    `super-admin` tokens for anyone holding it — off a public endpoint. The
+ *    flag comes from the store's own `is_secret` column rather than from a
+ *    guess about the key's name, because a heuristic that misses once
+ *    publishes a signing key.
+ * 2. Connection-string credentials are masked even when unflagged, so a URI
+ *    someone forgot to flag still does not leak its password.
+ */ export const redactConfiguration = (plain)=>{
+    const redacted = {};
+    for (const [group, items] of Object.entries(plain)){
+        redacted[group] = items.map((item)=>_extends({
+                key: item.key,
+                value: item.isSecret === true ? REDACTED : redactValue(item.value)
+            }, item.isSecret === true ? {
+                isSecret: true
+            } : {}));
+    }
+    return redacted;
+};
+
+//# sourceMappingURL=redact-configuration.js.map

package/dist/redact-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/redact-configuration.ts"],"sourcesContent":["import { ConfigurationPlain } from '@entifix/core';\n\n// Matches the `user:password@` credential segment of a connection URI\n// (`scheme://user:pass@host...`) so it can be masked in diagnostic output.\nconst CREDENTIALS_IN_URI = /^([a-z][a-z0-9+.-]*:\\/\\/)([^:@/]+):([^@/]+)@/i;\n\n/** Masks credentials embedded in a connection-string value, if present. */\nexport const redactValue = (value: unknown): unknown =>\n  typeof value === 'string'\n    ? value.replace(CREDENTIALS_IN_URI, '$1***:***@')\n    : value;\n\n/** What a secret's value is replaced with — its presence stays visible, its content does not. */\nconst REDACTED = '***';\n\n/**\n * Returns a copy of a {@link ConfigurationPlain} safe to expose from a service's\n * **unauthenticated** `GET /api/config` introspection endpoint.\n *\n * Two rules, and the first one carries the weight:\n *\n * 1. Any item the configuration store flagged `isSecret` is blanked outright.\n *    This is what keeps auth-service's RSA private key — a value that mints\n *    `super-admin` tokens for anyone holding it — off a public endpoint. The\n *    flag comes from the store's own `is_secret` column rather than from a\n *    guess about the key's name, because a heuristic that misses once\n *    publishes a signing key.\n * 2. Connection-string credentials are masked even when unflagged, so a URI\n *    someone forgot to flag still does not leak its password.\n */\nexport const redactConfiguration = (\n  plain: ConfigurationPlain,\n): ConfigurationPlain => {\n  const redacted: ConfigurationPlain = {};\n  for (const [group, items] of Object.entries(plain)) {\n    redacted[group] = items.map(item => ({\n      key: item.key,\n      value: item.isSecret === true ? REDACTED : redactValue(item.value),\n      ...(item.isSecret === true ? { isSecret: true } : {}),\n    }));\n  }\n  return redacted;\n};\n"],"names":["CREDENTIALS_IN_URI","redactValue","value","replace","REDACTED","redactConfiguration","plain","redacted","group","items","Object","entries","map","item","key","isSecret"],"mappings":";AAEA,sEAAsE;AACtE,2EAA2E;AAC3E,MAAMA,qBAAqB;AAE3B,yEAAyE,GACzE,OAAO,MAAMC,cAAc,CAACC,QAC1B,OAAOA,UAAU,WACbA,MAAMC,OAAO,CAACH,oBAAoB,gBAClCE,MAAM;AAEZ,+FAA+F,GAC/F,MAAME,WAAW;AAEjB;;;;;;;;;;;;;;CAcC,GACD,OAAO,MAAMC,sBAAsB,CACjCC;IAEA,MAAMC,WAA+B,CAAC;IACtC,KAAK,MAAM,CAACC,OAAOC,MAAM,IAAIC,OAAOC,OAAO,CAACL,OAAQ;QAClDC,QAAQ,CAACC,MAAM,GAAGC,MAAMG,GAAG,CAACC,CAAAA,OAAS;gBACnCC,KAAKD,KAAKC,GAAG;gBACbZ,OAAOW,KAAKE,QAAQ,KAAK,OAAOX,WAAWH,YAAYY,KAAKX,KAAK;eAC7DW,KAAKE,QAAQ,KAAK,OAAO;gBAAEA,UAAU;YAAK,IAAI,CAAC;IAEvD;IACA,OAAOR;AACT,EAAE"}

package/dist/serve-test-service.d.ts

@@ -0,0 +1,37 @@
+import { type ServiceDefinition } from './make-service.js';
+import { type WaitForHttpOptions } from './wait-for-http.js';
+/** A service booted in-process, and the handle that shuts it down. */
+export interface RunningTestService {
+    /** Origin the service is listening on, e.g. `http://127.0.0.1:53211`. */
+    readonly baseUrl: string;
+    /** Interrupts the launch fiber, releasing every Layer finalizer. */
+    close(): Promise<void>;
+}
+export interface ServeTestServiceOptions extends WaitForHttpOptions {
+    /** Fixed port. Omit to bind an ephemeral one, which is what tests want. */
+    port?: number;
+}
+/**
+ * Asks the OS for a free port by binding one and letting it go again.
+ *
+ * Exported because an ephemeral port is useful to any in-process boot, and
+ * because a helper with its own name is easier to reason about than an inline
+ * promise inside the launch sequence.
+ */
+export declare const freePort: () => Promise<number>;
+/**
+ * Boots a service definition in-process on an ephemeral port and waits until it
+ * answers `/api/health`.
+ *
+ * This is the seam the e2e `mock` profile runs on: the service's REAL `router`
+ * and the REAL {@link makeServerLayer} wiring are used, with only the `appLayer`
+ * swapped for one built from driver fakes. So the routes, the use-cases, the
+ * repository adapter and the query translation all execute — what is absent is
+ * the infrastructure, not the service.
+ *
+ * A boot failure (a Layer that dies) surfaces here rather than as a readiness
+ * timeout: the launch fiber is raced against the health check, so a missing
+ * dependency reports its own cause.
+ */
+export declare const serveTestService: <E, R>(def: ServiceDefinition<E, R>, { port, ...waitOptions }?: ServeTestServiceOptions) => Promise<RunningTestService>;
+//# sourceMappingURL=serve-test-service.d.ts.map

package/dist/serve-test-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve-test-service.d.ts","sourceRoot":"","sources":["../src/serve-test-service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAe,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE1E,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,uBAAwB,SAAQ,kBAAkB;IACjE,2EAA2E;IAC3E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,QAAO,OAAO,CAAC,MAAM,CAUtC,CAAC;AAEL;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAAU,CAAC,EAAE,CAAC,EACzC,KAAK,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC5B,2BAA0B,uBAA4B,KACrD,OAAO,CAAC,kBAAkB,CA6B5B,CAAC"}

package/dist/serve-test-service.js

@@ -0,0 +1,64 @@
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { createServer } from 'node:http';
+import { Effect, Fiber, Layer } from 'effect';
+import { makeServerLayer } from './make-service.js';
+import { waitForHttp } from './wait-for-http.js';
+/**
+ * Asks the OS for a free port by binding one and letting it go again.
+ *
+ * Exported because an ephemeral port is useful to any in-process boot, and
+ * because a helper with its own name is easier to reason about than an inline
+ * promise inside the launch sequence.
+ */ export const freePort = ()=>new Promise((resolve, reject)=>{
+        const probe = createServer();
+        probe.on('error', reject);
+        probe.listen(0, '127.0.0.1', ()=>{
+            const { port } = probe.address();
+            probe.close(()=>{
+                resolve(port);
+            });
+        });
+    });
+/**
+ * Boots a service definition in-process on an ephemeral port and waits until it
+ * answers `/api/health`.
+ *
+ * This is the seam the e2e `mock` profile runs on: the service's REAL `router`
+ * and the REAL {@link makeServerLayer} wiring are used, with only the `appLayer`
+ * swapped for one built from driver fakes. So the routes, the use-cases, the
+ * repository adapter and the query translation all execute — what is absent is
+ * the infrastructure, not the service.
+ *
+ * A boot failure (a Layer that dies) surfaces here rather than as a readiness
+ * timeout: the launch fiber is raced against the health check, so a missing
+ * dependency reports its own cause.
+ */ export const serveTestService = async (def, _1 = void 0)=>{
+    let _ref = [
+        _1
+    ], [_ref1 = {}] = _ref, { port } = _ref1, waitOptions = _object_without_properties_loose(_ref1, [
+        "port"
+    ]);
+    const boundPort = port != null ? port : await freePort();
+    const baseUrl = `http://127.0.0.1:${boundPort}`;
+    const fiber = Effect.runFork(Layer.launch(makeServerLayer(def, boundPort)));
+    // `Layer.launch` only ends when the service stops, so any failure of the
+    // launch fiber during startup is the real reason the health check would
+    // otherwise have timed out. `Fiber.join` re-raises the cause, so the defect
+    // that killed the Layer — not a generic timeout — is what gets reported.
+    const launchFailure = Effect.runPromise(Fiber.join(fiber)).catch((error)=>{
+        throw new Error(`The service exited during startup: ${String(error)}`);
+    });
+    // The same rejection fires again on a clean shutdown, when nobody is racing
+    // it any more. Observed here so it is never an unhandled rejection.
+    launchFailure.catch(()=>undefined);
+    await Promise.race([
+        waitForHttp(`${baseUrl}/api/health`, waitOptions),
+        launchFailure
+    ]);
+    return {
+        baseUrl,
+        close: ()=>Effect.runPromise(Fiber.interrupt(fiber)).then(()=>undefined)
+    };
+};
+
+//# sourceMappingURL=serve-test-service.js.map

package/dist/serve-test-service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/serve-test-service.ts"],"sourcesContent":["import { createServer } from 'node:http';\nimport type { AddressInfo } from 'node:net';\n\nimport { Effect, Fiber, Layer } from 'effect';\n\nimport { makeServerLayer, type ServiceDefinition } from './make-service.js';\nimport { waitForHttp, type WaitForHttpOptions } from './wait-for-http.js';\n\n/** A service booted in-process, and the handle that shuts it down. */\nexport interface RunningTestService {\n  /** Origin the service is listening on, e.g. `http://127.0.0.1:53211`. */\n  readonly baseUrl: string;\n  /** Interrupts the launch fiber, releasing every Layer finalizer. */\n  close(): Promise<void>;\n}\n\nexport interface ServeTestServiceOptions extends WaitForHttpOptions {\n  /** Fixed port. Omit to bind an ephemeral one, which is what tests want. */\n  port?: number;\n}\n\n/**\n * Asks the OS for a free port by binding one and letting it go again.\n *\n * Exported because an ephemeral port is useful to any in-process boot, and\n * because a helper with its own name is easier to reason about than an inline\n * promise inside the launch sequence.\n */\nexport const freePort = (): Promise<number> =>\n  new Promise<number>((resolve, reject) => {\n    const probe = createServer();\n    probe.on('error', reject);\n    probe.listen(0, '127.0.0.1', () => {\n      const { port } = probe.address() as AddressInfo;\n      probe.close(() => {\n        resolve(port);\n      });\n    });\n  });\n\n/**\n * Boots a service definition in-process on an ephemeral port and waits until it\n * answers `/api/health`.\n *\n * This is the seam the e2e `mock` profile runs on: the service's REAL `router`\n * and the REAL {@link makeServerLayer} wiring are used, with only the `appLayer`\n * swapped for one built from driver fakes. So the routes, the use-cases, the\n * repository adapter and the query translation all execute — what is absent is\n * the infrastructure, not the service.\n *\n * A boot failure (a Layer that dies) surfaces here rather than as a readiness\n * timeout: the launch fiber is raced against the health check, so a missing\n * dependency reports its own cause.\n */\nexport const serveTestService = async <E, R>(\n  def: ServiceDefinition<E, R>,\n  { port, ...waitOptions }: ServeTestServiceOptions = {},\n): Promise<RunningTestService> => {\n  const boundPort = port ?? (await freePort());\n  const baseUrl = `http://127.0.0.1:${boundPort}`;\n\n  const fiber = Effect.runFork(Layer.launch(makeServerLayer(def, boundPort)));\n\n  // `Layer.launch` only ends when the service stops, so any failure of the\n  // launch fiber during startup is the real reason the health check would\n  // otherwise have timed out. `Fiber.join` re-raises the cause, so the defect\n  // that killed the Layer — not a generic timeout — is what gets reported.\n  const launchFailure = Effect.runPromise(Fiber.join(fiber)).catch(\n    (error: unknown) => {\n      throw new Error(`The service exited during startup: ${String(error)}`);\n    },\n  );\n  // The same rejection fires again on a clean shutdown, when nobody is racing\n  // it any more. Observed here so it is never an unhandled rejection.\n  launchFailure.catch(() => undefined);\n\n  await Promise.race([\n    waitForHttp(`${baseUrl}/api/health`, waitOptions),\n    launchFailure,\n  ]);\n\n  return {\n    baseUrl,\n    close: () =>\n      Effect.runPromise(Fiber.interrupt(fiber)).then(() => undefined),\n  };\n};\n"],"names":["createServer","Effect","Fiber","Layer","makeServerLayer","waitForHttp","freePort","Promise","resolve","reject","probe","on","listen","port","address","close","serveTestService","def","waitOptions","boundPort","baseUrl","fiber","runFork","launch","launchFailure","runPromise","join","catch","error","Error","String","undefined","race","interrupt","then"],"mappings":";AAAA,SAASA,YAAY,QAAQ,YAAY;AAGzC,SAASC,MAAM,EAAEC,KAAK,EAAEC,KAAK,QAAQ,SAAS;AAE9C,SAASC,eAAe,QAAgC,oBAAoB;AAC5E,SAASC,WAAW,QAAiC,qBAAqB;AAe1E;;;;;;CAMC,GACD,OAAO,MAAMC,WAAW,IACtB,IAAIC,QAAgB,CAACC,SAASC;QAC5B,MAAMC,QAAQV;QACdU,MAAMC,EAAE,CAAC,SAASF;QAClBC,MAAME,MAAM,CAAC,GAAG,aAAa;YAC3B,MAAM,EAAEC,IAAI,EAAE,GAAGH,MAAMI,OAAO;YAC9BJ,MAAMK,KAAK,CAAC;gBACVP,QAAQK;YACV;QACF;IACF,GAAG;AAEL;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMG,mBAAmB,OAC9BC;;;gBACoD,CAAC,WAArD,EAAEJ,IAAI,EAA2C,UAAtCK;;;IAEX,MAAMC,YAAYN,eAAAA,OAAS,MAAMP;IACjC,MAAMc,UAAU,CAAC,iBAAiB,EAAED,WAAW;IAE/C,MAAME,QAAQpB,OAAOqB,OAAO,CAACnB,MAAMoB,MAAM,CAACnB,gBAAgBa,KAAKE;IAE/D,yEAAyE;IACzE,wEAAwE;IACxE,4EAA4E;IAC5E,yEAAyE;IACzE,MAAMK,gBAAgBvB,OAAOwB,UAAU,CAACvB,MAAMwB,IAAI,CAACL,QAAQM,KAAK,CAC9D,CAACC;QACC,MAAM,IAAIC,MAAM,CAAC,mCAAmC,EAAEC,OAAOF,QAAQ;IACvE;IAEF,4EAA4E;IAC5E,oEAAoE;IACpEJ,cAAcG,KAAK,CAAC,IAAMI;IAE1B,MAAMxB,QAAQyB,IAAI,CAAC;QACjB3B,YAAY,GAAGe,QAAQ,WAAW,CAAC,EAAEF;QACrCM;KACD;IAED,OAAO;QACLJ;QACAL,OAAO,IACLd,OAAOwB,UAAU,CAACvB,MAAM+B,SAAS,CAACZ,QAAQa,IAAI,CAAC,IAAMH;IACzD;AACF,EAAE"}

package/dist/service-description-route.d.ts

@@ -0,0 +1,65 @@
+import { HttpRouter } from '@effect/platform';
+import type { BoundSubscription } from '@entifix/business';
+import { HealthRegistryTag, WiringRegistryTag } from '@entifix/business';
+/**
+ * The path the wiring document is served at.
+ *
+ * Two **static** segments, which matters: `HttpRouter` resolves through
+ * `find-my-way-ts`, where a static segment beats a parametric one but there is
+ * no backtracking once a parametric branch has matched. A `/api/:something`
+ * route registered anywhere in the same router would otherwise swallow this one
+ * and answer its own `404` — the failure ADR 0026 hit with `$metadata`.
+ */
+export declare const SERVICE_DESCRIPTION_PATH = "/api/$service";
+/** One thing this process is connected to, named logically. */
+export interface DescribedTarget {
+    /** The Store's register name, an exchange, or a service. Never a URI. */
+    readonly name: string;
+    /** The readiness probe that covers it, so the two documents line up. */
+    readonly probe: string;
+}
+/**
+ * What a service says about its own wiring.
+ *
+ * Shape, not values — `/api/config` is the sibling that serves the parameters a
+ * service was given, redacted. Keeping them apart is deliberate: one is redacted
+ * because it holds credentials, the other gated because it holds a map, and
+ * merging them forces the stricter rule onto both (ADR 0031).
+ */
+export interface ServiceDescription {
+    readonly service: string;
+    /**
+     * The slices this process hosts. More than one means co-deployment
+     * (ADR 0021) — `marketplace-admin-service` runs the `transaction` slice too.
+     */
+    readonly slices: readonly string[];
+    readonly stores: readonly DescribedTarget[];
+    readonly brokers: readonly DescribedTarget[];
+    readonly upstreams: readonly DescribedTarget[];
+    /** Distinct event names this process has emitted since boot. */
+    readonly published: readonly string[];
+    /** The bus bindings this process actually made. */
+    readonly subscriptions: readonly BoundSubscription[];
+}
+/**
+ * Mount `GET /api/$service` on a router.
+ *
+ * **Gated by `X-Service-Token`.** This names every store, exchange and upstream
+ * a service has, which is a reconnaissance map rather than diagnostics. The
+ * repository's precedent on maps of the model is uniform: `$metadata` answers
+ * `404` rather than `403` so it cannot be walked as an oracle, readiness serves
+ * probe names only, and `redactConfiguration` blanks anything flagged secret
+ * because `/api/config` is unauthenticated. The health endpoints stay open —
+ * a probe cannot hold a credential.
+ *
+ * The token is fleet membership, which is the right shape here: the readers are
+ * `dev-infra:map` and CI, not a person and not a browser.
+ *
+ * **Logical names only.** Nothing in the response is a URI, and emphatically
+ * nothing is `tenant_<organizationId>` — the tenant databases are named after
+ * organizations, so leaking one turns a wiring document into a customer list.
+ * The names come from a probe's `targets`, which are Store register names by
+ * construction.
+ */
+export declare const withServiceDescriptionRoute: <E, R>(router: HttpRouter.HttpRouter<E, R>, serviceName: string, slices: readonly string[]) => HttpRouter.HttpRouter<import("@effect/platform/HttpBody").HttpBodyError | E, HealthRegistryTag | WiringRegistryTag | R>;
+//# sourceMappingURL=service-description-route.d.ts.map

package/dist/service-description-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-description-route.d.ts","sourceRoot":"","sources":["../src/service-description-route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAsB,MAAM,kBAAkB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAa,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAKzE;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AAExD,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;IAC/C,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,mDAAmD;IACnD,QAAQ,CAAC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACtD;AAwCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,GAAI,CAAC,EAAE,CAAC,EAC9C,QAAQ,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EACnC,aAAa,MAAM,EACnB,QAAQ,SAAS,MAAM,EAAE,4HAWxB,CAAC"}

package/dist/service-description-route.js

@@ -0,0 +1,59 @@
+import { HttpRouter, HttpServerResponse } from '@effect/platform';
+import { HealthRegistryTag, WiringRegistryTag } from '@entifix/business';
+import { Effect } from 'effect';
+import { requireServiceToken } from './auth/service-token.js';
+/**
+ * The path the wiring document is served at.
+ *
+ * Two **static** segments, which matters: `HttpRouter` resolves through
+ * `find-my-way-ts`, where a static segment beats a parametric one but there is
+ * no backtracking once a parametric branch has matched. A `/api/:something`
+ * route registered anywhere in the same router would otherwise swallow this one
+ * and answer its own `404` — the failure ADR 0026 hit with `$metadata`.
+ */ export const SERVICE_DESCRIPTION_PATH = '/api/$service';
+/**
+ * Everything the two registries know, sorted by what it is.
+ *
+ * Generated from the **health probe registrations**, which is the one source
+ * that cannot drift: a service that gains a datastore gains its probe by merging
+ * the client's probe layer, so it gains a line here with no edit of its own.
+ */ const describe = (service, slices)=>Effect.gen(function*() {
+        const health = yield* HealthRegistryTag;
+        const wiring = yield* WiringRegistryTag;
+        const probes = yield* health.probes;
+        const ofKind = (kind)=>probes.filter((probe)=>probe.kind === kind).flatMap((probe)=>probe.targets.map((name)=>({
+                        name,
+                        probe: probe.name
+                    })));
+        return {
+            service,
+            slices,
+            stores: ofKind('datastore'),
+            brokers: ofKind('broker'),
+            upstreams: ofKind('upstream'),
+            published: yield* wiring.published,
+            subscriptions: yield* wiring.subscriptions
+        };
+    });
+/**
+ * Mount `GET /api/$service` on a router.
+ *
+ * **Gated by `X-Service-Token`.** This names every store, exchange and upstream
+ * a service has, which is a reconnaissance map rather than diagnostics. The
+ * repository's precedent on maps of the model is uniform: `$metadata` answers
+ * `404` rather than `403` so it cannot be walked as an oracle, readiness serves
+ * probe names only, and `redactConfiguration` blanks anything flagged secret
+ * because `/api/config` is unauthenticated. The health endpoints stay open —
+ * a probe cannot hold a credential.
+ *
+ * The token is fleet membership, which is the right shape here: the readers are
+ * `dev-infra:map` and CI, not a person and not a browser.
+ *
+ * **Logical names only.** Nothing in the response is a URI, and emphatically
+ * nothing is `tenant_<organizationId>` — the tenant databases are named after
+ * organizations, so leaking one turns a wiring document into a customer list.
+ * The names come from a probe's `targets`, which are Store register names by
+ * construction.
+ */ export const withServiceDescriptionRoute = (router, serviceName, slices)=>router.pipe(HttpRouter.get(SERVICE_DESCRIPTION_PATH, requireServiceToken(Effect.flatMap(describe(serviceName, slices), (description)=>HttpServerResponse.json(description)))));
+
+//# sourceMappingURL=service-description-route.js.map

package/dist/service-description-route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/service-description-route.ts"],"sourcesContent":["import { HttpRouter, HttpServerResponse } from '@effect/platform';\nimport type { BoundSubscription, ProbeKind } from '@entifix/business';\nimport { HealthRegistryTag, WiringRegistryTag } from '@entifix/business';\nimport { Effect } from 'effect';\n\nimport { requireServiceToken } from './auth/service-token.js';\n\n/**\n * The path the wiring document is served at.\n *\n * Two **static** segments, which matters: `HttpRouter` resolves through\n * `find-my-way-ts`, where a static segment beats a parametric one but there is\n * no backtracking once a parametric branch has matched. A `/api/:something`\n * route registered anywhere in the same router would otherwise swallow this one\n * and answer its own `404` — the failure ADR 0026 hit with `$metadata`.\n */\nexport const SERVICE_DESCRIPTION_PATH = '/api/$service';\n\n/** One thing this process is connected to, named logically. */\nexport interface DescribedTarget {\n  /** The Store's register name, an exchange, or a service. Never a URI. */\n  readonly name: string;\n  /** The readiness probe that covers it, so the two documents line up. */\n  readonly probe: string;\n}\n\n/**\n * What a service says about its own wiring.\n *\n * Shape, not values — `/api/config` is the sibling that serves the parameters a\n * service was given, redacted. Keeping them apart is deliberate: one is redacted\n * because it holds credentials, the other gated because it holds a map, and\n * merging them forces the stricter rule onto both (ADR 0031).\n */\nexport interface ServiceDescription {\n  readonly service: string;\n  /**\n   * The slices this process hosts. More than one means co-deployment\n   * (ADR 0021) — `marketplace-admin-service` runs the `transaction` slice too.\n   */\n  readonly slices: readonly string[];\n  readonly stores: readonly DescribedTarget[];\n  readonly brokers: readonly DescribedTarget[];\n  readonly upstreams: readonly DescribedTarget[];\n  /** Distinct event names this process has emitted since boot. */\n  readonly published: readonly string[];\n  /** The bus bindings this process actually made. */\n  readonly subscriptions: readonly BoundSubscription[];\n}\n\n/**\n * Everything the two registries know, sorted by what it is.\n *\n * Generated from the **health probe registrations**, which is the one source\n * that cannot drift: a service that gains a datastore gains its probe by merging\n * the client's probe layer, so it gains a line here with no edit of its own.\n */\nconst describe = (\n  service: string,\n  slices: readonly string[],\n): Effect.Effect<\n  ServiceDescription,\n  never,\n  HealthRegistryTag | WiringRegistryTag\n> =>\n  Effect.gen(function* () {\n    const health = yield* HealthRegistryTag;\n    const wiring = yield* WiringRegistryTag;\n    const probes = yield* health.probes;\n\n    const ofKind = (kind: ProbeKind): readonly DescribedTarget[] =>\n      probes\n        .filter(probe => probe.kind === kind)\n        .flatMap(probe =>\n          probe.targets.map(name => ({ name, probe: probe.name })),\n        );\n\n    return {\n      service,\n      slices,\n      stores: ofKind('datastore'),\n      brokers: ofKind('broker'),\n      upstreams: ofKind('upstream'),\n      published: yield* wiring.published,\n      subscriptions: yield* wiring.subscriptions,\n    };\n  });\n\n/**\n * Mount `GET /api/$service` on a router.\n *\n * **Gated by `X-Service-Token`.** This names every store, exchange and upstream\n * a service has, which is a reconnaissance map rather than diagnostics. The\n * repository's precedent on maps of the model is uniform: `$metadata` answers\n * `404` rather than `403` so it cannot be walked as an oracle, readiness serves\n * probe names only, and `redactConfiguration` blanks anything flagged secret\n * because `/api/config` is unauthenticated. The health endpoints stay open —\n * a probe cannot hold a credential.\n *\n * The token is fleet membership, which is the right shape here: the readers are\n * `dev-infra:map` and CI, not a person and not a browser.\n *\n * **Logical names only.** Nothing in the response is a URI, and emphatically\n * nothing is `tenant_<organizationId>` — the tenant databases are named after\n * organizations, so leaking one turns a wiring document into a customer list.\n * The names come from a probe's `targets`, which are Store register names by\n * construction.\n */\nexport const withServiceDescriptionRoute = <E, R>(\n  router: HttpRouter.HttpRouter<E, R>,\n  serviceName: string,\n  slices: readonly string[],\n) =>\n  router.pipe(\n    HttpRouter.get(\n      SERVICE_DESCRIPTION_PATH,\n      requireServiceToken(\n        Effect.flatMap(describe(serviceName, slices), description =>\n          HttpServerResponse.json(description),\n        ),\n      ),\n    ),\n  );\n"],"names":["HttpRouter","HttpServerResponse","HealthRegistryTag","WiringRegistryTag","Effect","requireServiceToken","SERVICE_DESCRIPTION_PATH","describe","service","slices","gen","health","wiring","probes","ofKind","kind","filter","probe","flatMap","targets","map","name","stores","brokers","upstreams","published","subscriptions","withServiceDescriptionRoute","router","serviceName","pipe","get","description","json"],"mappings":"AAAA,SAASA,UAAU,EAAEC,kBAAkB,QAAQ,mBAAmB;AAElE,SAASC,iBAAiB,EAAEC,iBAAiB,QAAQ,oBAAoB;AACzE,SAASC,MAAM,QAAQ,SAAS;AAEhC,SAASC,mBAAmB,QAAQ,0BAA0B;AAE9D;;;;;;;;CAQC,GACD,OAAO,MAAMC,2BAA2B,gBAAgB;AAkCxD;;;;;;CAMC,GACD,MAAMC,WAAW,CACfC,SACAC,SAMAL,OAAOM,GAAG,CAAC;QACT,MAAMC,SAAS,OAAOT;QACtB,MAAMU,SAAS,OAAOT;QACtB,MAAMU,SAAS,OAAOF,OAAOE,MAAM;QAEnC,MAAMC,SAAS,CAACC,OACdF,OACGG,MAAM,CAACC,CAAAA,QAASA,MAAMF,IAAI,KAAKA,MAC/BG,OAAO,CAACD,CAAAA,QACPA,MAAME,OAAO,CAACC,GAAG,CAACC,CAAAA,OAAS,CAAA;wBAAEA;wBAAMJ,OAAOA,MAAMI,IAAI;oBAAC,CAAA;QAG3D,OAAO;YACLb;YACAC;YACAa,QAAQR,OAAO;YACfS,SAAST,OAAO;YAChBU,WAAWV,OAAO;YAClBW,WAAW,OAAOb,OAAOa,SAAS;YAClCC,eAAe,OAAOd,OAAOc,aAAa;QAC5C;IACF;AAEF;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,MAAMC,8BAA8B,CACzCC,QACAC,aACApB,SAEAmB,OAAOE,IAAI,CACT9B,WAAW+B,GAAG,CACZzB,0BACAD,oBACED,OAAOc,OAAO,CAACX,SAASsB,aAAapB,SAASuB,CAAAA,cAC5C/B,mBAAmBgC,IAAI,CAACD,iBAI9B"}

package/dist/sse.d.ts

@@ -0,0 +1,40 @@
+import { HttpServerResponse } from '@effect/platform';
+import { type DomainEvent } from '@entifix/core';
+import { Stream } from 'effect';
+/**
+ * One `EventSource` frame.
+ *
+ * `id:` carries the message's own id — `<transactionId>:<step>` for a
+ * transaction event — so the `Last-Event-ID` a browser re-sends on reconnect
+ * names a message that actually exists, rather than a counter invented for the
+ * wire. The server does not replay it (ADR 0036); the client reconciles by
+ * re-reading the record.
+ *
+ * `data:` is a full `event` envelope, which is what keeps the stream from
+ * becoming a fourth framing: the same bytes a bus consumer would read.
+ */
+export declare const sseFrame: (event: DomainEvent) => string;
+export interface SseResponseOptions {
+    /**
+     * Unix seconds at which to close the connection — the verified token's `exp`.
+     *
+     * A held-open response has no next request to fail verification, so the bound
+     * every REST route gets implicitly has to be applied explicitly here. The
+     * browser reconnects with the cookie the app refreshed in the meantime
+     * (ADR 0036). Omitted, the stream runs until the client goes away.
+     */
+    readonly expiresAt?: number;
+    /** Injectable for tests; defaults to the wall clock. */
+    readonly now?: () => number;
+}
+/**
+ * Serves a stream of domain events as `text/event-stream`.
+ *
+ * `cache-control: no-store` is not politeness — a cached event stream is served
+ * to whoever asks next, and this one is scoped to a single principal. The
+ * response is deliberately *not* rebuilt anywhere downstream: the Next proxy has
+ * a pass-through arm for exactly this content type, because reading the body to
+ * completion first holds the request open forever and delivers nothing.
+ */
+export declare const sseResponse: (events: Stream.Stream<DomainEvent>, { expiresAt, now }?: SseResponseOptions) => HttpServerResponse.HttpServerResponse;
+//# sourceMappingURL=sse.d.ts.map

package/dist/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../src/sse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,eAAe,CAAC;AACpE,OAAO,EAAoB,MAAM,EAAE,MAAM,QAAQ,CAAC;AAclD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,WAAW,KAAG,MAC4B,CAAC;AAE3E,MAAM,WAAW,kBAAkB;IACjC;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAClC,qBAA+B,kBAAuB,KACrD,kBAAkB,CAAC,kBA0CrB,CAAC"}

package/dist/sse.js

@@ -0,0 +1,62 @@
+import { HttpServerResponse } from '@effect/platform';
+import { makeEventEnvelope } from '@entifix/core';
+import { Duration, Effect, Stream } from 'effect';
+/**
+ * How often an idle connection emits a comment frame.
+ *
+ * An SSE connection that sends nothing for minutes is indistinguishable from a
+ * dead one to anything between the browser and the service, and a proxy that
+ * decides it is dead closes it with no error either side can report. A comment
+ * (`:` and nothing else) is ignored by `EventSource` and costs three bytes.
+ */ const KEEPALIVE = Duration.seconds(20);
+const encoder = new TextEncoder();
+/**
+ * One `EventSource` frame.
+ *
+ * `id:` carries the message's own id — `<transactionId>:<step>` for a
+ * transaction event — so the `Last-Event-ID` a browser re-sends on reconnect
+ * names a message that actually exists, rather than a counter invented for the
+ * wire. The server does not replay it (ADR 0036); the client reconciles by
+ * re-reading the record.
+ *
+ * `data:` is a full `event` envelope, which is what keeps the stream from
+ * becoming a fourth framing: the same bytes a bus consumer would read.
+ */ export const sseFrame = (event)=>`id: ${event.id}\ndata: ${JSON.stringify(makeEventEnvelope(event))}\n\n`;
+/**
+ * Serves a stream of domain events as `text/event-stream`.
+ *
+ * `cache-control: no-store` is not politeness — a cached event stream is served
+ * to whoever asks next, and this one is scoped to a single principal. The
+ * response is deliberately *not* rebuilt anywhere downstream: the Next proxy has
+ * a pass-through arm for exactly this content type, because reading the body to
+ * completion first holds the request open forever and delivers nothing.
+ */ export const sseResponse = (events, { expiresAt, now = Date.now } = {})=>{
+    const keepalive = Stream.repeatEffect(Effect.as(Effect.sleep(KEEPALIVE), ': keepalive\n\n'));
+    const frames = Stream.merge(Stream.map(events, sseFrame), keepalive, {
+        haltStrategy: 'left'
+    });
+    // An opening comment, emitted before anything has happened.
+    //
+    // Not cosmetic: a chunked response writes its headers with its first chunk,
+    // so a stream that stays silent until something occurs leaves the client in
+    // `CONNECTING` — indefinitely, since a stream whose whole purpose is to be
+    // idle most of the time may have nothing to say for hours. Measured: without
+    // it, `fetch` against this route does not resolve at all.
+    const opened = Stream.concat(Stream.make(': open\n\n'), frames);
+    const bounded = expiresAt === undefined ? opened : Stream.interruptWhen(opened, // Never negative: an already-expired token closes at once rather than
+    // scheduling a sleep into the past, which `Effect.sleep` treats as
+    // zero anyway but reads as an oversight.
+    Effect.sleep(Duration.millis(Math.max(0, expiresAt * 1000 - now()))));
+    return HttpServerResponse.stream(Stream.map(bounded, (frame)=>encoder.encode(frame)), {
+        contentType: 'text/event-stream',
+        headers: {
+            'cache-control': 'no-store',
+            connection: 'keep-alive',
+            // nginx buffers a proxied response by default, which would hold every
+            // frame until the stream ends — that is, forever.
+            'x-accel-buffering': 'no'
+        }
+    });
+};
+
+//# sourceMappingURL=sse.js.map

package/dist/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sse.ts"],"sourcesContent":["import { HttpServerResponse } from '@effect/platform';\nimport { type DomainEvent, makeEventEnvelope } from '@entifix/core';\nimport { Duration, Effect, Stream } from 'effect';\n\n/**\n * How often an idle connection emits a comment frame.\n *\n * An SSE connection that sends nothing for minutes is indistinguishable from a\n * dead one to anything between the browser and the service, and a proxy that\n * decides it is dead closes it with no error either side can report. A comment\n * (`:` and nothing else) is ignored by `EventSource` and costs three bytes.\n */\nconst KEEPALIVE = Duration.seconds(20);\n\nconst encoder = new TextEncoder();\n\n/**\n * One `EventSource` frame.\n *\n * `id:` carries the message's own id — `<transactionId>:<step>` for a\n * transaction event — so the `Last-Event-ID` a browser re-sends on reconnect\n * names a message that actually exists, rather than a counter invented for the\n * wire. The server does not replay it (ADR 0036); the client reconciles by\n * re-reading the record.\n *\n * `data:` is a full `event` envelope, which is what keeps the stream from\n * becoming a fourth framing: the same bytes a bus consumer would read.\n */\nexport const sseFrame = (event: DomainEvent): string =>\n  `id: ${event.id}\\ndata: ${JSON.stringify(makeEventEnvelope(event))}\\n\\n`;\n\nexport interface SseResponseOptions {\n  /**\n   * Unix seconds at which to close the connection — the verified token's `exp`.\n   *\n   * A held-open response has no next request to fail verification, so the bound\n   * every REST route gets implicitly has to be applied explicitly here. The\n   * browser reconnects with the cookie the app refreshed in the meantime\n   * (ADR 0036). Omitted, the stream runs until the client goes away.\n   */\n  readonly expiresAt?: number;\n  /** Injectable for tests; defaults to the wall clock. */\n  readonly now?: () => number;\n}\n\n/**\n * Serves a stream of domain events as `text/event-stream`.\n *\n * `cache-control: no-store` is not politeness — a cached event stream is served\n * to whoever asks next, and this one is scoped to a single principal. The\n * response is deliberately *not* rebuilt anywhere downstream: the Next proxy has\n * a pass-through arm for exactly this content type, because reading the body to\n * completion first holds the request open forever and delivers nothing.\n */\nexport const sseResponse = (\n  events: Stream.Stream<DomainEvent>,\n  { expiresAt, now = Date.now }: SseResponseOptions = {},\n): HttpServerResponse.HttpServerResponse => {\n  const keepalive = Stream.repeatEffect(\n    Effect.as(Effect.sleep(KEEPALIVE), ': keepalive\\n\\n'),\n  );\n\n  const frames = Stream.merge(Stream.map(events, sseFrame), keepalive, {\n    haltStrategy: 'left',\n  });\n\n  // An opening comment, emitted before anything has happened.\n  //\n  // Not cosmetic: a chunked response writes its headers with its first chunk,\n  // so a stream that stays silent until something occurs leaves the client in\n  // `CONNECTING` — indefinitely, since a stream whose whole purpose is to be\n  // idle most of the time may have nothing to say for hours. Measured: without\n  // it, `fetch` against this route does not resolve at all.\n  const opened = Stream.concat(Stream.make(': open\\n\\n'), frames);\n\n  const bounded =\n    expiresAt === undefined\n      ? opened\n      : Stream.interruptWhen(\n          opened,\n          // Never negative: an already-expired token closes at once rather than\n          // scheduling a sleep into the past, which `Effect.sleep` treats as\n          // zero anyway but reads as an oversight.\n          Effect.sleep(Duration.millis(Math.max(0, expiresAt * 1000 - now()))),\n        );\n\n  return HttpServerResponse.stream(\n    Stream.map(bounded, frame => encoder.encode(frame)),\n    {\n      contentType: 'text/event-stream',\n      headers: {\n        'cache-control': 'no-store',\n        connection: 'keep-alive',\n        // nginx buffers a proxied response by default, which would hold every\n        // frame until the stream ends — that is, forever.\n        'x-accel-buffering': 'no',\n      },\n    },\n  );\n};\n"],"names":["HttpServerResponse","makeEventEnvelope","Duration","Effect","Stream","KEEPALIVE","seconds","encoder","TextEncoder","sseFrame","event","id","JSON","stringify","sseResponse","events","expiresAt","now","Date","keepalive","repeatEffect","as","sleep","frames","merge","map","haltStrategy","opened","concat","make","bounded","undefined","interruptWhen","millis","Math","max","stream","frame","encode","contentType","headers","connection"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,mBAAmB;AACtD,SAA2BC,iBAAiB,QAAQ,gBAAgB;AACpE,SAASC,QAAQ,EAAEC,MAAM,EAAEC,MAAM,QAAQ,SAAS;AAElD;;;;;;;CAOC,GACD,MAAMC,YAAYH,SAASI,OAAO,CAAC;AAEnC,MAAMC,UAAU,IAAIC;AAEpB;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,WAAW,CAACC,QACvB,CAAC,IAAI,EAAEA,MAAMC,EAAE,CAAC,QAAQ,EAAEC,KAAKC,SAAS,CAACZ,kBAAkBS,QAAQ,IAAI,CAAC,CAAC;AAgB3E;;;;;;;;CAQC,GACD,OAAO,MAAMI,cAAc,CACzBC,QACA,EAAEC,SAAS,EAAEC,MAAMC,KAAKD,GAAG,EAAsB,GAAG,CAAC,CAAC;IAEtD,MAAME,YAAYf,OAAOgB,YAAY,CACnCjB,OAAOkB,EAAE,CAAClB,OAAOmB,KAAK,CAACjB,YAAY;IAGrC,MAAMkB,SAASnB,OAAOoB,KAAK,CAACpB,OAAOqB,GAAG,CAACV,QAAQN,WAAWU,WAAW;QACnEO,cAAc;IAChB;IAEA,4DAA4D;IAC5D,EAAE;IACF,4EAA4E;IAC5E,4EAA4E;IAC5E,2EAA2E;IAC3E,6EAA6E;IAC7E,0DAA0D;IAC1D,MAAMC,SAASvB,OAAOwB,MAAM,CAACxB,OAAOyB,IAAI,CAAC,eAAeN;IAExD,MAAMO,UACJd,cAAce,YACVJ,SACAvB,OAAO4B,aAAa,CAClBL,QACA,sEAAsE;IACtE,mEAAmE;IACnE,yCAAyC;IACzCxB,OAAOmB,KAAK,CAACpB,SAAS+B,MAAM,CAACC,KAAKC,GAAG,CAAC,GAAGnB,YAAY,OAAOC;IAGpE,OAAOjB,mBAAmBoC,MAAM,CAC9BhC,OAAOqB,GAAG,CAACK,SAASO,CAAAA,QAAS9B,QAAQ+B,MAAM,CAACD,SAC5C;QACEE,aAAa;QACbC,SAAS;YACP,iBAAiB;YACjBC,YAAY;YACZ,sEAAsE;YACtE,kDAAkD;YAClD,qBAAqB;QACvB;IACF;AAEJ,EAAE"}

package/dist/wait-for-http.d.ts

@@ -0,0 +1,18 @@
+/** How long a readiness wait keeps trying, and how often. */
+export interface WaitForHttpOptions {
+    /** Total attempts before giving up. */
+    attempts?: number;
+    /** Pause between attempts, in milliseconds. */
+    delayMs?: number;
+}
+/**
+ * Polls `url` until it answers, or throws once the attempts run out.
+ *
+ * A freshly launched server is not listening on the very next tick, so an
+ * in-process boot needs a readiness gate before the first request. This is that
+ * gate, kept separate from the boot itself so both its outcomes — answers on a
+ * later attempt, never answers at all — are reachable from a spec without
+ * racing a real server.
+ */
+export declare const waitForHttp: (url: string, { attempts, delayMs }?: WaitForHttpOptions) => Promise<void>;
+//# sourceMappingURL=wait-for-http.d.ts.map

package/dist/wait-for-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for-http.d.ts","sourceRoot":"","sources":["../src/wait-for-http.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAOD;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GACtB,KAAK,MAAM,EACX,wBAAiC,kBAAuB,KACvD,OAAO,CAAC,IAAI,CAgBd,CAAC"}

package/dist/wait-for-http.js

@@ -0,0 +1,26 @@
+/** How long a readiness wait keeps trying, and how often. */ const sleep = (ms)=>new Promise((resolve)=>{
+        setTimeout(resolve, ms);
+    });
+/**
+ * Polls `url` until it answers, or throws once the attempts run out.
+ *
+ * A freshly launched server is not listening on the very next tick, so an
+ * in-process boot needs a readiness gate before the first request. This is that
+ * gate, kept separate from the boot itself so both its outcomes — answers on a
+ * later attempt, never answers at all — are reachable from a spec without
+ * racing a real server.
+ */ export const waitForHttp = async (url, { attempts = 50, delayMs = 50 } = {})=>{
+    let lastError;
+    for(let attempt = 0; attempt < attempts; attempt += 1){
+        try {
+            await fetch(url);
+            return;
+        } catch (error) {
+            lastError = error;
+            await sleep(delayMs);
+        }
+    }
+    throw new Error(`Timed out waiting for ${url} after ${attempts} attempts: ${String(lastError)}`);
+};
+
+//# sourceMappingURL=wait-for-http.js.map

package/dist/wait-for-http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/wait-for-http.ts"],"sourcesContent":["/** How long a readiness wait keeps trying, and how often. */\nexport interface WaitForHttpOptions {\n  /** Total attempts before giving up. */\n  attempts?: number;\n  /** Pause between attempts, in milliseconds. */\n  delayMs?: number;\n}\n\nconst sleep = (ms: number) =>\n  new Promise<void>(resolve => {\n    setTimeout(resolve, ms);\n  });\n\n/**\n * Polls `url` until it answers, or throws once the attempts run out.\n *\n * A freshly launched server is not listening on the very next tick, so an\n * in-process boot needs a readiness gate before the first request. This is that\n * gate, kept separate from the boot itself so both its outcomes — answers on a\n * later attempt, never answers at all — are reachable from a spec without\n * racing a real server.\n */\nexport const waitForHttp = async (\n  url: string,\n  { attempts = 50, delayMs = 50 }: WaitForHttpOptions = {},\n): Promise<void> => {\n  let lastError: unknown;\n\n  for (let attempt = 0; attempt < attempts; attempt += 1) {\n    try {\n      await fetch(url);\n      return;\n    } catch (error) {\n      lastError = error;\n      await sleep(delayMs);\n    }\n  }\n\n  throw new Error(\n    `Timed out waiting for ${url} after ${attempts} attempts: ${String(lastError)}`,\n  );\n};\n"],"names":["sleep","ms","Promise","resolve","setTimeout","waitForHttp","url","attempts","delayMs","lastError","attempt","fetch","error","Error","String"],"mappings":"AAAA,2DAA2D,GAQ3D,MAAMA,QAAQ,CAACC,KACb,IAAIC,QAAcC,CAAAA;QAChBC,WAAWD,SAASF;IACtB;AAEF;;;;;;;;CAQC,GACD,OAAO,MAAMI,cAAc,OACzBC,KACA,EAAEC,WAAW,EAAE,EAAEC,UAAU,EAAE,EAAsB,GAAG,CAAC,CAAC;IAExD,IAAIC;IAEJ,IAAK,IAAIC,UAAU,GAAGA,UAAUH,UAAUG,WAAW,EAAG;QACtD,IAAI;YACF,MAAMC,MAAML;YACZ;QACF,EAAE,OAAOM,OAAO;YACdH,YAAYG;YACZ,MAAMZ,MAAMQ;QACd;IACF;IAEA,MAAM,IAAIK,MACR,CAAC,sBAAsB,EAAEP,IAAI,OAAO,EAAEC,SAAS,WAAW,EAAEO,OAAOL,YAAY;AAEnF,EAAE"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@entifix/service-shell",
+  "version": "0.1.0-0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/effect/service-shell"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "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"
+    }
+  },
+  "nx": {
+    "tags": [
+      "layer:shell",
+      "scope:shared",
+      "shell:base",
+      "tier:4"
+    ],
+    "sourceRoot": "packages/effect/service-shell/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/effect/service-shell/dist",
+          "main": "packages/effect/service-shell/src/index.ts",
+          "tsConfig": "packages/effect/service-shell/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@effect/opentelemetry": "0.64.0",
+    "@effect/platform": "0.97.1",
+    "@effect/platform-node": "0.108.1",
+    "@opentelemetry/context-async-hooks": "2.10.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "0.221.0",
+    "@opentelemetry/exporter-trace-otlp-http": "0.221.0",
+    "@opentelemetry/sdk-metrics": "2.10.0",
+    "@opentelemetry/sdk-trace-base": "2.10.0",
+    "@swc/helpers": "0.5.23",
+    "@entifix/authz": "0.1.0-0",
+    "@entifix/core": "0.1.0-0",
+    "@entifix/tooling": "0.1.0-0",
+    "@entifix/business": "0.1.0-0"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "1.9.1",
+    "effect": "3.22.1",
+    "@entifix/testing-unit": "0.1.0-0"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9 <2",
+    "effect": ">=3.22 <4"
+  }
+}