@entifix/tooling 0.1.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r10c Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @entifix/tooling
+
+Framework-free platform tooling built on the OpenTelemetry standard. One leaf
+package, two independent modules (no shared interface between them):
+
+- **`@entifix/tooling/logging`** — a leveled logging facade
+  (`createLogger`) over a pluggable `LogSink`. Stamps every record with the
+  service name, an OTel `SeverityNumber`, and — when a span is active — the
+  active `trace_id`/`span_id`, so logs join their traces in Grafana. Ships three
+  sinks: `makeStdoutJsonSink` (backend/prod → tailed by the Collector's filelog
+  receiver), `makeOtlpHttpLogSink` (dev → OTLP to `grafana/otel-lgtm`), and the
+  `LogSink` interface for anything else (browser `/api/telemetry`, test doubles).
+  `redactRecord` masks the canonical secret keys before any sink sees them.
+
+- **`@entifix/tooling/tracking`** — the product-analytics facade: the
+  `Tracker` interface (`track`/`identify`/`flag`) plus a `NoopTracker`. The real
+  vendor adapter lives in `@entifix/posthog`; `Tracker` is
+  provided per environment behind `TrackerTag` (Effect `Context.Tag`).
+
+Why framework-free (not an Effect wrap): the browser and Next server are not
+Effect, so only an OTel-standard facade can serve every runtime from one package.
+Effect backends adapt it in ~10 lines at their composition root (`Logger.replace`).
+
+The package depends only on `@opentelemetry/api`.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './logging/index.js';
+export * from './tracking/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './logging/index.js';
+export * from './tracking/index.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './logging/index.js';\nexport * from './tracking/index.js';\n"],"names":[],"mappings":"AAAA,cAAc,qBAAqB;AACnC,cAAc,sBAAsB"}

package/dist/logging/create-logger.d.ts

@@ -0,0 +1,24 @@
+import type { Attributes, Logger, LogLevel, LogRecord, LogSink } from './types.js';
+/** Options for {@link createLogger}. */
+export interface CreateLoggerOptions {
+    /** Emitting service name (`service.name`). */
+    readonly service: string;
+    /** Minimum level; anything below is dropped before the sink. */
+    readonly level: LogLevel;
+    /** Where records go (stdout JSON, OTLP, HTTP proxy, in-memory test double). */
+    readonly sink: LogSink;
+    /** Record transform applied before emit. Defaults to {@link redactRecord}. */
+    readonly redact?: (record: LogRecord) => LogRecord;
+    /** Attributes stamped on every record (used by {@link Logger.child}). */
+    readonly bindings?: Attributes;
+    /** Clock seam for deterministic tests. Defaults to `() => new Date()`. */
+    readonly now?: () => Date;
+}
+/**
+ * Build a {@link Logger} over a {@link LogSink}. Framework-free: it stamps
+ * timestamp, service, severity number and (when present) trace/span ids, applies
+ * redaction, and hands the record to the sink. Transport and backend are chosen
+ * entirely by which sink is passed, so the same call site works in every runtime.
+ */
+export declare const createLogger: (options: CreateLoggerOptions) => Logger;
+//# sourceMappingURL=create-logger.d.ts.map

package/dist/logging/create-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-logger.d.ts","sourceRoot":"","sources":["../../src/logging/create-logger.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,UAAU,EACV,MAAM,EACN,QAAQ,EACR,SAAS,EACT,OAAO,EAER,MAAM,YAAY,CAAC;AAEpB,wCAAwC;AACxC,MAAM,WAAW,mBAAmB;IAClC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,SAAS,CAAC;IACnD,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B;AAqBD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,mBAAmB,KAAG,MAyC3D,CAAC"}

package/dist/logging/create-logger.js

@@ -0,0 +1,70 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { trace } from '@opentelemetry/api';
+import { SEVERITY_NUMBER, shouldLog } from './level.js';
+import { redactRecord } from './redact.js';
+const serializeError = (error)=>error instanceof Error ? {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+    } : {
+        name: 'NonError',
+        message: String(error)
+    };
+/**
+ * The trace-correlation link: read the active OpenTelemetry span. When a span is
+ * active (e.g. an in-flight HTTP request under `@effect/opentelemetry`), its
+ * ids are stamped on the record so the log joins its trace in Grafana/Tempo.
+ */ const activeSpanContext = ()=>{
+    const span = trace.getActiveSpan();
+    if (span === undefined) {
+        return {};
+    }
+    const context = span.spanContext();
+    return {
+        traceId: context.traceId,
+        spanId: context.spanId
+    };
+};
+/**
+ * Build a {@link Logger} over a {@link LogSink}. Framework-free: it stamps
+ * timestamp, service, severity number and (when present) trace/span ids, applies
+ * redaction, and hands the record to the sink. Transport and backend are chosen
+ * entirely by which sink is passed, so the same call site works in every runtime.
+ */ export const createLogger = (options)=>{
+    var _options_bindings, _options_redact, _options_now;
+    const { service, level, sink } = options;
+    const bindings = (_options_bindings = options.bindings) != null ? _options_bindings : {};
+    const redact = (_options_redact = options.redact) != null ? _options_redact : redactRecord;
+    const now = (_options_now = options.now) != null ? _options_now : ()=>new Date();
+    const write = (logLevel, message, attributes, error)=>{
+        if (!shouldLog(level, logLevel)) {
+            return;
+        }
+        const { traceId, spanId } = activeSpanContext();
+        const record = _extends({
+            timestamp: now().toISOString(),
+            level: logLevel,
+            severityNumber: SEVERITY_NUMBER[logLevel],
+            service,
+            message,
+            attributes: _extends({}, bindings, attributes)
+        }, traceId !== undefined ? {
+            traceId,
+            spanId
+        } : {}, error !== undefined ? {
+            error: serializeError(error)
+        } : {});
+        sink.emit(redact(record));
+    };
+    return {
+        debug: (message, attributes = {})=>write('debug', message, attributes),
+        info: (message, attributes = {})=>write('info', message, attributes),
+        warn: (message, attributes = {})=>write('warn', message, attributes),
+        error: (message, error, attributes = {})=>write('error', message, attributes, error),
+        child: (bindingsToAdd)=>createLogger(_extends({}, options, {
+                bindings: _extends({}, bindings, bindingsToAdd)
+            }))
+    };
+};
+
+//# sourceMappingURL=create-logger.js.map

package/dist/logging/create-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging/create-logger.ts"],"sourcesContent":["import { trace } from '@opentelemetry/api';\n\nimport { SEVERITY_NUMBER, shouldLog } from './level.js';\nimport { redactRecord } from './redact.js';\nimport type {\n  Attributes,\n  Logger,\n  LogLevel,\n  LogRecord,\n  LogSink,\n  SerializedError,\n} from './types.js';\n\n/** Options for {@link createLogger}. */\nexport interface CreateLoggerOptions {\n  /** Emitting service name (`service.name`). */\n  readonly service: string;\n  /** Minimum level; anything below is dropped before the sink. */\n  readonly level: LogLevel;\n  /** Where records go (stdout JSON, OTLP, HTTP proxy, in-memory test double). */\n  readonly sink: LogSink;\n  /** Record transform applied before emit. Defaults to {@link redactRecord}. */\n  readonly redact?: (record: LogRecord) => LogRecord;\n  /** Attributes stamped on every record (used by {@link Logger.child}). */\n  readonly bindings?: Attributes;\n  /** Clock seam for deterministic tests. Defaults to `() => new Date()`. */\n  readonly now?: () => Date;\n}\n\nconst serializeError = (error: unknown): SerializedError =>\n  error instanceof Error\n    ? { name: error.name, message: error.message, stack: error.stack }\n    : { name: 'NonError', message: String(error) };\n\n/**\n * The trace-correlation link: read the active OpenTelemetry span. When a span is\n * active (e.g. an in-flight HTTP request under `@effect/opentelemetry`), its\n * ids are stamped on the record so the log joins its trace in Grafana/Tempo.\n */\nconst activeSpanContext = (): { traceId?: string; spanId?: string } => {\n  const span = trace.getActiveSpan();\n  if (span === undefined) {\n    return {};\n  }\n  const context = span.spanContext();\n  return { traceId: context.traceId, spanId: context.spanId };\n};\n\n/**\n * Build a {@link Logger} over a {@link LogSink}. Framework-free: it stamps\n * timestamp, service, severity number and (when present) trace/span ids, applies\n * redaction, and hands the record to the sink. Transport and backend are chosen\n * entirely by which sink is passed, so the same call site works in every runtime.\n */\nexport const createLogger = (options: CreateLoggerOptions): Logger => {\n  const { service, level, sink } = options;\n  const bindings = options.bindings ?? {};\n  const redact = options.redact ?? redactRecord;\n  const now = options.now ?? (() => new Date());\n\n  const write = (\n    logLevel: LogLevel,\n    message: string,\n    attributes: Attributes,\n    error?: unknown,\n  ): void => {\n    if (!shouldLog(level, logLevel)) {\n      return;\n    }\n    const { traceId, spanId } = activeSpanContext();\n    const record: LogRecord = {\n      timestamp: now().toISOString(),\n      level: logLevel,\n      severityNumber: SEVERITY_NUMBER[logLevel],\n      service,\n      message,\n      attributes: { ...bindings, ...attributes },\n      ...(traceId !== undefined ? { traceId, spanId } : {}),\n      ...(error !== undefined ? { error: serializeError(error) } : {}),\n    };\n    sink.emit(redact(record));\n  };\n\n  return {\n    debug: (message, attributes = {}) => write('debug', message, attributes),\n    info: (message, attributes = {}) => write('info', message, attributes),\n    warn: (message, attributes = {}) => write('warn', message, attributes),\n    error: (message, error, attributes = {}) =>\n      write('error', message, attributes, error),\n    child: bindingsToAdd =>\n      createLogger({\n        ...options,\n        bindings: { ...bindings, ...bindingsToAdd },\n      }),\n  };\n};\n"],"names":["trace","SEVERITY_NUMBER","shouldLog","redactRecord","serializeError","error","Error","name","message","stack","String","activeSpanContext","span","getActiveSpan","undefined","context","spanContext","traceId","spanId","createLogger","options","service","level","sink","bindings","redact","now","Date","write","logLevel","attributes","record","timestamp","toISOString","severityNumber","emit","debug","info","warn","child","bindingsToAdd"],"mappings":";AAAA,SAASA,KAAK,QAAQ,qBAAqB;AAE3C,SAASC,eAAe,EAAEC,SAAS,QAAQ,aAAa;AACxD,SAASC,YAAY,QAAQ,cAAc;AA0B3C,MAAMC,iBAAiB,CAACC,QACtBA,iBAAiBC,QACb;QAAEC,MAAMF,MAAME,IAAI;QAAEC,SAASH,MAAMG,OAAO;QAAEC,OAAOJ,MAAMI,KAAK;IAAC,IAC/D;QAAEF,MAAM;QAAYC,SAASE,OAAOL;IAAO;AAEjD;;;;CAIC,GACD,MAAMM,oBAAoB;IACxB,MAAMC,OAAOZ,MAAMa,aAAa;IAChC,IAAID,SAASE,WAAW;QACtB,OAAO,CAAC;IACV;IACA,MAAMC,UAAUH,KAAKI,WAAW;IAChC,OAAO;QAAEC,SAASF,QAAQE,OAAO;QAAEC,QAAQH,QAAQG,MAAM;IAAC;AAC5D;AAEA;;;;;CAKC,GACD,OAAO,MAAMC,eAAe,CAACC;QAEVA,mBACFA,iBACHA;IAHZ,MAAM,EAAEC,OAAO,EAAEC,KAAK,EAAEC,IAAI,EAAE,GAAGH;IACjC,MAAMI,YAAWJ,oBAAAA,QAAQI,QAAQ,YAAhBJ,oBAAoB,CAAC;IACtC,MAAMK,UAASL,kBAAAA,QAAQK,MAAM,YAAdL,kBAAkBjB;IACjC,MAAMuB,OAAMN,eAAAA,QAAQM,GAAG,YAAXN,eAAgB,IAAM,IAAIO;IAEtC,MAAMC,QAAQ,CACZC,UACArB,SACAsB,YACAzB;QAEA,IAAI,CAACH,UAAUoB,OAAOO,WAAW;YAC/B;QACF;QACA,MAAM,EAAEZ,OAAO,EAAEC,MAAM,EAAE,GAAGP;QAC5B,MAAMoB,SAAoB;YACxBC,WAAWN,MAAMO,WAAW;YAC5BX,OAAOO;YACPK,gBAAgBjC,eAAe,CAAC4B,SAAS;YACzCR;YACAb;YACAsB,YAAY,aAAKN,UAAaM;WAC1Bb,YAAYH,YAAY;YAAEG;YAASC;QAAO,IAAI,CAAC,GAC/Cb,UAAUS,YAAY;YAAET,OAAOD,eAAeC;QAAO,IAAI,CAAC;QAEhEkB,KAAKY,IAAI,CAACV,OAAOM;IACnB;IAEA,OAAO;QACLK,OAAO,CAAC5B,SAASsB,aAAa,CAAC,CAAC,GAAKF,MAAM,SAASpB,SAASsB;QAC7DO,MAAM,CAAC7B,SAASsB,aAAa,CAAC,CAAC,GAAKF,MAAM,QAAQpB,SAASsB;QAC3DQ,MAAM,CAAC9B,SAASsB,aAAa,CAAC,CAAC,GAAKF,MAAM,QAAQpB,SAASsB;QAC3DzB,OAAO,CAACG,SAASH,OAAOyB,aAAa,CAAC,CAAC,GACrCF,MAAM,SAASpB,SAASsB,YAAYzB;QACtCkC,OAAOC,CAAAA,gBACLrB,aAAa,aACRC;gBACHI,UAAU,aAAKA,UAAagB;;IAElC;AACF,EAAE"}

package/dist/logging/index.d.ts

@@ -0,0 +1,7 @@
+export * from './create-logger.js';
+export * from './level.js';
+export * from './redact.js';
+export * from './sinks/otlp-http-log-sink.js';
+export * from './sinks/stdout-json-sink.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logging/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,YAAY,CAAC"}

package/dist/logging/index.js

@@ -0,0 +1,8 @@
+export * from './create-logger.js';
+export * from './level.js';
+export * from './redact.js';
+export * from './sinks/otlp-http-log-sink.js';
+export * from './sinks/stdout-json-sink.js';
+export * from './types.js';
+
+//# sourceMappingURL=index.js.map

package/dist/logging/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging/index.ts"],"sourcesContent":["export * from './create-logger.js';\nexport * from './level.js';\nexport * from './redact.js';\nexport * from './sinks/otlp-http-log-sink.js';\nexport * from './sinks/stdout-json-sink.js';\nexport * from './types.js';\n"],"names":[],"mappings":"AAAA,cAAc,qBAAqB;AACnC,cAAc,aAAa;AAC3B,cAAc,cAAc;AAC5B,cAAc,gCAAgC;AAC9C,cAAc,8BAA8B;AAC5C,cAAc,aAAa"}

package/dist/logging/level.d.ts

@@ -0,0 +1,13 @@
+import type { LogLevel } from './types.js';
+/**
+ * OpenTelemetry `SeverityNumber` for each level (DEBUG=5, INFO=9, WARN=13,
+ * ERROR=17). Emitting the standard number lets any OTel backend filter/colour
+ * logs without knowing our string names.
+ */
+export declare const SEVERITY_NUMBER: Record<LogLevel, number>;
+/**
+ * Whether a record at `level` passes a logger configured with minimum `min`.
+ * A DEBUG record on a WARN logger is dropped before it ever reaches a sink.
+ */
+export declare const shouldLog: (min: LogLevel, level: LogLevel) => boolean;
+//# sourceMappingURL=level.d.ts.map

package/dist/logging/level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/logging/level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAKpD,CAAC;AAUF;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,QAAQ,EAAE,OAAO,QAAQ,KAAG,OACnB,CAAC"}

package/dist/logging/level.js

@@ -0,0 +1,22 @@
+/**
+ * OpenTelemetry `SeverityNumber` for each level (DEBUG=5, INFO=9, WARN=13,
+ * ERROR=17). Emitting the standard number lets any OTel backend filter/colour
+ * logs without knowing our string names.
+ */ export const SEVERITY_NUMBER = {
+    debug: 5,
+    info: 9,
+    warn: 13,
+    error: 17
+};
+/** Ascending rank used to gate records below the configured minimum. */ const LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+};
+/**
+ * Whether a record at `level` passes a logger configured with minimum `min`.
+ * A DEBUG record on a WARN logger is dropped before it ever reaches a sink.
+ */ export const shouldLog = (min, level)=>LEVEL_ORDER[level] >= LEVEL_ORDER[min];
+
+//# sourceMappingURL=level.js.map

package/dist/logging/level.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging/level.ts"],"sourcesContent":["import type { LogLevel } from './types.js';\n\n/**\n * OpenTelemetry `SeverityNumber` for each level (DEBUG=5, INFO=9, WARN=13,\n * ERROR=17). Emitting the standard number lets any OTel backend filter/colour\n * logs without knowing our string names.\n */\nexport const SEVERITY_NUMBER: Record<LogLevel, number> = {\n  debug: 5,\n  info: 9,\n  warn: 13,\n  error: 17,\n};\n\n/** Ascending rank used to gate records below the configured minimum. */\nconst LEVEL_ORDER: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\n/**\n * Whether a record at `level` passes a logger configured with minimum `min`.\n * A DEBUG record on a WARN logger is dropped before it ever reaches a sink.\n */\nexport const shouldLog = (min: LogLevel, level: LogLevel): boolean =>\n  LEVEL_ORDER[level] >= LEVEL_ORDER[min];\n"],"names":["SEVERITY_NUMBER","debug","info","warn","error","LEVEL_ORDER","shouldLog","min","level"],"mappings":"AAEA;;;;CAIC,GACD,OAAO,MAAMA,kBAA4C;IACvDC,OAAO;IACPC,MAAM;IACNC,MAAM;IACNC,OAAO;AACT,EAAE;AAEF,sEAAsE,GACtE,MAAMC,cAAwC;IAC5CJ,OAAO;IACPC,MAAM;IACNC,MAAM;IACNC,OAAO;AACT;AAEA;;;CAGC,GACD,OAAO,MAAME,YAAY,CAACC,KAAeC,QACvCH,WAAW,CAACG,MAAM,IAAIH,WAAW,CAACE,IAAI,CAAC"}

package/dist/logging/redact.d.ts

@@ -0,0 +1,14 @@
+import type { Attributes, LogRecord } from './types.js';
+/**
+ * The canonical scrub list — the same keys the `/api/telemetry` proxy and the
+ * Collector gateway processor strip. Kept here so every enforcement point shares
+ * one source of truth: a secret never reaches a sink regardless of the path.
+ */
+export declare const DEFAULT_REDACT_KEYS: readonly string[];
+/** The value a redacted attribute is replaced with. */
+export declare const REDACTED = "***";
+/** Returns a copy of `attributes` with any matching key's value masked. */
+export declare const redactAttributes: (attributes: Attributes, keys?: readonly string[]) => Attributes;
+/** Default record redactor: masks sensitive attribute values, keeps the rest. */
+export declare const redactRecord: (record: LogRecord, keys?: readonly string[]) => LogRecord;
+//# sourceMappingURL=redact.d.ts.map

package/dist/logging/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../src/logging/redact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAQhD,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,QAAQ,QAAQ,CAAC;AAS9B,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB,GAC3B,YAAY,UAAU,EACtB,OAAM,SAAS,MAAM,EAAwB,KAC5C,UAMF,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,YAAY,GACvB,QAAQ,SAAS,EACjB,OAAM,SAAS,MAAM,EAAwB,KAC5C,SAGD,CAAC"}

package/dist/logging/redact.js

@@ -0,0 +1,31 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * The canonical scrub list — the same keys the `/api/telemetry` proxy and the
+ * Collector gateway processor strip. Kept here so every enforcement point shares
+ * one source of truth: a secret never reaches a sink regardless of the path.
+ */ export const DEFAULT_REDACT_KEYS = [
+    'authorization',
+    'cookie',
+    'set-cookie',
+    'entifix_at',
+    'entifix_sid',
+    'password',
+    'token'
+];
+/** The value a redacted attribute is replaced with. */ export const REDACTED = '***';
+const isRedactedKey = (key, keys)=>{
+    const lower = key.toLowerCase();
+    return keys.some((candidate)=>candidate.toLowerCase() === lower);
+};
+/** Returns a copy of `attributes` with any matching key's value masked. */ export const redactAttributes = (attributes, keys = DEFAULT_REDACT_KEYS)=>{
+    const out = {};
+    for (const [key, value] of Object.entries(attributes)){
+        out[key] = isRedactedKey(key, keys) ? REDACTED : value;
+    }
+    return out;
+};
+/** Default record redactor: masks sensitive attribute values, keeps the rest. */ export const redactRecord = (record, keys = DEFAULT_REDACT_KEYS)=>_extends({}, record, {
+        attributes: redactAttributes(record.attributes, keys)
+    });
+
+//# sourceMappingURL=redact.js.map

package/dist/logging/redact.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging/redact.ts"],"sourcesContent":["import type { Attributes, LogRecord } from './types.js';\n\n/**\n * The canonical scrub list — the same keys the `/api/telemetry` proxy and the\n * Collector gateway processor strip. Kept here so every enforcement point shares\n * one source of truth: a secret never reaches a sink regardless of the path.\n */\nexport const DEFAULT_REDACT_KEYS: readonly string[] = [\n  'authorization',\n  'cookie',\n  'set-cookie',\n  'entifix_at',\n  'entifix_sid',\n  'password',\n  'token',\n];\n\n/** The value a redacted attribute is replaced with. */\nexport const REDACTED = '***';\n\ntype AttributeValue = Attributes[string];\n\nconst isRedactedKey = (key: string, keys: readonly string[]): boolean => {\n  const lower = key.toLowerCase();\n  return keys.some(candidate => candidate.toLowerCase() === lower);\n};\n\n/** Returns a copy of `attributes` with any matching key's value masked. */\nexport const redactAttributes = (\n  attributes: Attributes,\n  keys: readonly string[] = DEFAULT_REDACT_KEYS,\n): Attributes => {\n  const out: Record<string, AttributeValue> = {};\n  for (const [key, value] of Object.entries(attributes)) {\n    out[key] = isRedactedKey(key, keys) ? REDACTED : (value as AttributeValue);\n  }\n  return out;\n};\n\n/** Default record redactor: masks sensitive attribute values, keeps the rest. */\nexport const redactRecord = (\n  record: LogRecord,\n  keys: readonly string[] = DEFAULT_REDACT_KEYS,\n): LogRecord => ({\n  ...record,\n  attributes: redactAttributes(record.attributes, keys),\n});\n"],"names":["DEFAULT_REDACT_KEYS","REDACTED","isRedactedKey","key","keys","lower","toLowerCase","some","candidate","redactAttributes","attributes","out","value","Object","entries","redactRecord","record"],"mappings":";AAEA;;;;CAIC,GACD,OAAO,MAAMA,sBAAyC;IACpD;IACA;IACA;IACA;IACA;IACA;IACA;CACD,CAAC;AAEF,qDAAqD,GACrD,OAAO,MAAMC,WAAW,MAAM;AAI9B,MAAMC,gBAAgB,CAACC,KAAaC;IAClC,MAAMC,QAAQF,IAAIG,WAAW;IAC7B,OAAOF,KAAKG,IAAI,CAACC,CAAAA,YAAaA,UAAUF,WAAW,OAAOD;AAC5D;AAEA,yEAAyE,GACzE,OAAO,MAAMI,mBAAmB,CAC9BC,YACAN,OAA0BJ,mBAAmB;IAE7C,MAAMW,MAAsC,CAAC;IAC7C,KAAK,MAAM,CAACR,KAAKS,MAAM,IAAIC,OAAOC,OAAO,CAACJ,YAAa;QACrDC,GAAG,CAACR,IAAI,GAAGD,cAAcC,KAAKC,QAAQH,WAAYW;IACpD;IACA,OAAOD;AACT,EAAE;AAEF,+EAA+E,GAC/E,OAAO,MAAMI,eAAe,CAC1BC,QACAZ,OAA0BJ,mBAAmB,GAC9B,aACZgB;QACHN,YAAYD,iBAAiBO,OAAON,UAAU,EAAEN;OAC/C"}

package/dist/logging/sinks/otlp-http-log-sink.d.ts

@@ -0,0 +1,37 @@
+import type { LogRecord, LogSink } from '../types.js';
+/**
+ * The dev sink: batches records and POSTs them as OTLP/HTTP JSON to a Collector
+ * (the local `grafana/otel-lgtm` at its `/v1/logs` endpoint). Hand-rolled on
+ * `fetch` so the framework-free leaf keeps a single runtime dep
+ * (`@opentelemetry/api`) instead of pulling the OTel logs SDK.
+ */
+export interface OtlpHttpLogSinkOptions {
+    /** Collector base URL, e.g. `http://127.0.0.1:30318`. `/v1/logs` is appended. */
+    readonly endpoint: string;
+    /** `service.name` stamped on the OTLP resource. */
+    readonly serviceName: string;
+    /** Flush once the buffer reaches this many records (default 20). */
+    readonly batchSize?: number;
+    /**
+     * Also flush on this interval (ms) so low-volume producers are not stuck below
+     * {@link batchSize}. Omit for size-only flushing. The timer is `unref`'d so it
+     * never keeps the process alive.
+     */
+    readonly flushIntervalMs?: number;
+    /** `fetch` seam; defaults to the global. */
+    readonly fetchImpl?: typeof fetch;
+    /** Called when a flush fails (default: swallow — telemetry is best-effort). */
+    readonly onError?: (error: unknown) => void;
+}
+/** A {@link LogSink} that can be flushed on demand (e.g. before shutdown). */
+export interface OtlpHttpLogSink extends LogSink {
+    flush(): Promise<void>;
+}
+/**
+ * Encode records into the OTLP/HTTP JSON `logs` payload. Exported so the shape
+ * is unit-testable without a live Collector.
+ */
+export declare const toOtlpLogsPayload: (records: readonly LogRecord[], serviceName: string) => unknown;
+/** Build a batching OTLP/HTTP log sink. */
+export declare const makeOtlpHttpLogSink: (options: OtlpHttpLogSinkOptions) => OtlpHttpLogSink;
+//# sourceMappingURL=otlp-http-log-sink.d.ts.map

package/dist/logging/sinks/otlp-http-log-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-http-log-sink.d.ts","sourceRoot":"","sources":["../../../src/logging/sinks/otlp-http-log-sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAgB,SAAQ,OAAO;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AA4CD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,SAAS,SAAS,EAAE,EAC7B,aAAa,MAAM,KAClB,OA2BD,CAAC;AAEH,2CAA2C;AAC3C,eAAO,MAAM,mBAAmB,GAC9B,SAAS,sBAAsB,KAC9B,eA8CF,CAAC"}

package/dist/logging/sinks/otlp-http-log-sink.js

@@ -0,0 +1,128 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+const toAnyValue = (value)=>{
+    if (typeof value === 'string') {
+        return {
+            stringValue: value
+        };
+    }
+    if (typeof value === 'number') {
+        return Number.isInteger(value) ? {
+            intValue: value
+        } : {
+            doubleValue: value
+        };
+    }
+    if (typeof value === 'boolean') {
+        return {
+            boolValue: value
+        };
+    }
+    // `null` (the only remaining AttributeValue) carries no typed value.
+    return {
+        stringValue: 'null'
+    };
+};
+const toKeyValues = (attributes)=>{
+    const out = [];
+    for (const [key, value] of Object.entries(attributes)){
+        if (value !== undefined) {
+            out.push({
+                key,
+                value: toAnyValue(value)
+            });
+        }
+    }
+    return out;
+};
+const SEVERITY_TEXT = {
+    debug: 'DEBUG',
+    info: 'INFO',
+    warn: 'WARN',
+    error: 'ERROR'
+};
+/**
+ * Encode records into the OTLP/HTTP JSON `logs` payload. Exported so the shape
+ * is unit-testable without a live Collector.
+ */ export const toOtlpLogsPayload = (records, serviceName)=>({
+        resourceLogs: [
+            {
+                resource: {
+                    attributes: [
+                        {
+                            key: 'service.name',
+                            value: {
+                                stringValue: serviceName
+                            }
+                        }
+                    ]
+                },
+                scopeLogs: [
+                    {
+                        scope: {
+                            name: '@entifix/tooling'
+                        },
+                        logRecords: records.map((record)=>_extends({
+                                timeUnixNano: (BigInt(Date.parse(record.timestamp)) * 1000000n).toString(),
+                                severityNumber: record.severityNumber,
+                                severityText: SEVERITY_TEXT[record.level],
+                                body: {
+                                    stringValue: record.message
+                                },
+                                attributes: toKeyValues(record.attributes)
+                            }, record.traceId !== undefined ? {
+                                traceId: record.traceId,
+                                spanId: record.spanId
+                            } : {}))
+                    }
+                ]
+            }
+        ]
+    });
+/** Build a batching OTLP/HTTP log sink. */ export const makeOtlpHttpLogSink = (options)=>{
+    var _options_batchSize, _options_fetchImpl, _options_onError;
+    const batchSize = (_options_batchSize = options.batchSize) != null ? _options_batchSize : 20;
+    // Resolve the global `fetch` at call time (bound to `globalThis`): a bare
+    // `fetch` reference can be dropped by a bundler, whereas `globalThis.fetch`
+    // survives bundling and stays correct in Node and the browser.
+    const fetchImpl = (_options_fetchImpl = options.fetchImpl) != null ? _options_fetchImpl : (input, init)=>globalThis.fetch(input, init);
+    const onError = (_options_onError = options.onError) != null ? _options_onError : ()=>undefined;
+    const url = `${options.endpoint}/v1/logs`;
+    let buffer = [];
+    const flush = async ()=>{
+        if (buffer.length === 0) {
+            return;
+        }
+        const batch = buffer;
+        buffer = [];
+        try {
+            const response = await fetchImpl(url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json'
+                },
+                body: JSON.stringify(toOtlpLogsPayload(batch, options.serviceName))
+            });
+            if (!response.ok) {
+                onError(new Error(`OTLP logs export failed: ${response.status}`));
+            }
+        } catch (error) {
+            onError(error);
+        }
+    };
+    if (options.flushIntervalMs !== undefined) {
+        const timer = setInterval(()=>void flush(), options.flushIntervalMs);
+        // Never let the flush timer hold the process open.
+        timer.unref == null ? void 0 : timer.unref.call(timer);
+    }
+    return {
+        emit: (record)=>{
+            buffer.push(record);
+            if (buffer.length >= batchSize) {
+                void flush();
+            }
+        },
+        flush
+    };
+};
+
+//# sourceMappingURL=otlp-http-log-sink.js.map

package/dist/logging/sinks/otlp-http-log-sink.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/logging/sinks/otlp-http-log-sink.ts"],"sourcesContent":["import type { AttributeValue, LogRecord, LogSink } from '../types.js';\n\n/**\n * The dev sink: batches records and POSTs them as OTLP/HTTP JSON to a Collector\n * (the local `grafana/otel-lgtm` at its `/v1/logs` endpoint). Hand-rolled on\n * `fetch` so the framework-free leaf keeps a single runtime dep\n * (`@opentelemetry/api`) instead of pulling the OTel logs SDK.\n */\nexport interface OtlpHttpLogSinkOptions {\n  /** Collector base URL, e.g. `http://127.0.0.1:30318`. `/v1/logs` is appended. */\n  readonly endpoint: string;\n  /** `service.name` stamped on the OTLP resource. */\n  readonly serviceName: string;\n  /** Flush once the buffer reaches this many records (default 20). */\n  readonly batchSize?: number;\n  /**\n   * Also flush on this interval (ms) so low-volume producers are not stuck below\n   * {@link batchSize}. Omit for size-only flushing. The timer is `unref`'d so it\n   * never keeps the process alive.\n   */\n  readonly flushIntervalMs?: number;\n  /** `fetch` seam; defaults to the global. */\n  readonly fetchImpl?: typeof fetch;\n  /** Called when a flush fails (default: swallow — telemetry is best-effort). */\n  readonly onError?: (error: unknown) => void;\n}\n\n/** A {@link LogSink} that can be flushed on demand (e.g. before shutdown). */\nexport interface OtlpHttpLogSink extends LogSink {\n  flush(): Promise<void>;\n}\n\ninterface OtlpAnyValue {\n  stringValue?: string;\n  intValue?: number;\n  doubleValue?: number;\n  boolValue?: boolean;\n}\n\nconst toAnyValue = (value: AttributeValue): OtlpAnyValue => {\n  if (typeof value === 'string') {\n    return { stringValue: value };\n  }\n  if (typeof value === 'number') {\n    return Number.isInteger(value)\n      ? { intValue: value }\n      : { doubleValue: value };\n  }\n  if (typeof value === 'boolean') {\n    return { boolValue: value };\n  }\n  // `null` (the only remaining AttributeValue) carries no typed value.\n  return { stringValue: 'null' };\n};\n\nconst toKeyValues = (\n  attributes: Record<string, AttributeValue | undefined>,\n): Array<{ key: string; value: OtlpAnyValue }> => {\n  const out: Array<{ key: string; value: OtlpAnyValue }> = [];\n  for (const [key, value] of Object.entries(attributes)) {\n    if (value !== undefined) {\n      out.push({ key, value: toAnyValue(value) });\n    }\n  }\n  return out;\n};\n\nconst SEVERITY_TEXT: Record<LogRecord['level'], string> = {\n  debug: 'DEBUG',\n  info: 'INFO',\n  warn: 'WARN',\n  error: 'ERROR',\n};\n\n/**\n * Encode records into the OTLP/HTTP JSON `logs` payload. Exported so the shape\n * is unit-testable without a live Collector.\n */\nexport const toOtlpLogsPayload = (\n  records: readonly LogRecord[],\n  serviceName: string,\n): unknown => ({\n  resourceLogs: [\n    {\n      resource: {\n        attributes: [\n          { key: 'service.name', value: { stringValue: serviceName } },\n        ],\n      },\n      scopeLogs: [\n        {\n          scope: { name: '@entifix/tooling' },\n          logRecords: records.map(record => ({\n            timeUnixNano: (\n              BigInt(Date.parse(record.timestamp)) * 1_000_000n\n            ).toString(),\n            severityNumber: record.severityNumber,\n            severityText: SEVERITY_TEXT[record.level],\n            body: { stringValue: record.message },\n            attributes: toKeyValues(record.attributes),\n            ...(record.traceId !== undefined\n              ? { traceId: record.traceId, spanId: record.spanId }\n              : {}),\n          })),\n        },\n      ],\n    },\n  ],\n});\n\n/** Build a batching OTLP/HTTP log sink. */\nexport const makeOtlpHttpLogSink = (\n  options: OtlpHttpLogSinkOptions,\n): OtlpHttpLogSink => {\n  const batchSize = options.batchSize ?? 20;\n  // Resolve the global `fetch` at call time (bound to `globalThis`): a bare\n  // `fetch` reference can be dropped by a bundler, whereas `globalThis.fetch`\n  // survives bundling and stays correct in Node and the browser.\n  const fetchImpl =\n    options.fetchImpl ?? ((input, init) => globalThis.fetch(input, init));\n  const onError = options.onError ?? (() => undefined);\n  const url = `${options.endpoint}/v1/logs`;\n  let buffer: LogRecord[] = [];\n\n  const flush = async (): Promise<void> => {\n    if (buffer.length === 0) {\n      return;\n    }\n    const batch = buffer;\n    buffer = [];\n    try {\n      const response = await fetchImpl(url, {\n        method: 'POST',\n        headers: { 'content-type': 'application/json' },\n        body: JSON.stringify(toOtlpLogsPayload(batch, options.serviceName)),\n      });\n      if (!response.ok) {\n        onError(new Error(`OTLP logs export failed: ${response.status}`));\n      }\n    } catch (error) {\n      onError(error);\n    }\n  };\n\n  if (options.flushIntervalMs !== undefined) {\n    const timer = setInterval(() => void flush(), options.flushIntervalMs);\n    // Never let the flush timer hold the process open.\n    (timer as { unref?: () => void }).unref?.();\n  }\n\n  return {\n    emit: (record: LogRecord) => {\n      buffer.push(record);\n      if (buffer.length >= batchSize) {\n        void flush();\n      }\n    },\n    flush,\n  };\n};\n"],"names":["toAnyValue","value","stringValue","Number","isInteger","intValue","doubleValue","boolValue","toKeyValues","attributes","out","key","Object","entries","undefined","push","SEVERITY_TEXT","debug","info","warn","error","toOtlpLogsPayload","records","serviceName","resourceLogs","resource","scopeLogs","scope","name","logRecords","map","record","timeUnixNano","BigInt","Date","parse","timestamp","toString","severityNumber","severityText","level","body","message","traceId","spanId","makeOtlpHttpLogSink","options","batchSize","fetchImpl","input","init","globalThis","fetch","onError","url","endpoint","buffer","flush","length","batch","response","method","headers","JSON","stringify","ok","Error","status","flushIntervalMs","timer","setInterval","unref","emit"],"mappings":";AAuCA,MAAMA,aAAa,CAACC;IAClB,IAAI,OAAOA,UAAU,UAAU;QAC7B,OAAO;YAAEC,aAAaD;QAAM;IAC9B;IACA,IAAI,OAAOA,UAAU,UAAU;QAC7B,OAAOE,OAAOC,SAAS,CAACH,SACpB;YAAEI,UAAUJ;QAAM,IAClB;YAAEK,aAAaL;QAAM;IAC3B;IACA,IAAI,OAAOA,UAAU,WAAW;QAC9B,OAAO;YAAEM,WAAWN;QAAM;IAC5B;IACA,qEAAqE;IACrE,OAAO;QAAEC,aAAa;IAAO;AAC/B;AAEA,MAAMM,cAAc,CAClBC;IAEA,MAAMC,MAAmD,EAAE;IAC3D,KAAK,MAAM,CAACC,KAAKV,MAAM,IAAIW,OAAOC,OAAO,CAACJ,YAAa;QACrD,IAAIR,UAAUa,WAAW;YACvBJ,IAAIK,IAAI,CAAC;gBAAEJ;gBAAKV,OAAOD,WAAWC;YAAO;QAC3C;IACF;IACA,OAAOS;AACT;AAEA,MAAMM,gBAAoD;IACxDC,OAAO;IACPC,MAAM;IACNC,MAAM;IACNC,OAAO;AACT;AAEA;;;CAGC,GACD,OAAO,MAAMC,oBAAoB,CAC/BC,SACAC,cACa,CAAA;QACbC,cAAc;YACZ;gBACEC,UAAU;oBACRhB,YAAY;wBACV;4BAAEE,KAAK;4BAAgBV,OAAO;gCAAEC,aAAaqB;4BAAY;wBAAE;qBAC5D;gBACH;gBACAG,WAAW;oBACT;wBACEC,OAAO;4BAAEC,MAAM;wBAAmB;wBAClCC,YAAYP,QAAQQ,GAAG,CAACC,CAAAA,SAAW;gCACjCC,cAAc,AACZC,CAAAA,OAAOC,KAAKC,KAAK,CAACJ,OAAOK,SAAS,KAAK,QAAU,AAAD,EAChDC,QAAQ;gCACVC,gBAAgBP,OAAOO,cAAc;gCACrCC,cAAcvB,aAAa,CAACe,OAAOS,KAAK,CAAC;gCACzCC,MAAM;oCAAEvC,aAAa6B,OAAOW,OAAO;gCAAC;gCACpCjC,YAAYD,YAAYuB,OAAOtB,UAAU;+BACrCsB,OAAOY,OAAO,KAAK7B,YACnB;gCAAE6B,SAASZ,OAAOY,OAAO;gCAAEC,QAAQb,OAAOa,MAAM;4BAAC,IACjD,CAAC;oBAET;iBACD;YACH;SACD;IACH,CAAA,EAAG;AAEH,yCAAyC,GACzC,OAAO,MAAMC,sBAAsB,CACjCC;QAEkBA,oBAKhBA,oBACcA;IANhB,MAAMC,aAAYD,qBAAAA,QAAQC,SAAS,YAAjBD,qBAAqB;IACvC,0EAA0E;IAC1E,4EAA4E;IAC5E,+DAA+D;IAC/D,MAAME,aACJF,qBAAAA,QAAQE,SAAS,YAAjBF,qBAAsB,CAACG,OAAOC,OAASC,WAAWC,KAAK,CAACH,OAAOC;IACjE,MAAMG,WAAUP,mBAAAA,QAAQO,OAAO,YAAfP,mBAAoB,IAAMhC;IAC1C,MAAMwC,MAAM,GAAGR,QAAQS,QAAQ,CAAC,QAAQ,CAAC;IACzC,IAAIC,SAAsB,EAAE;IAE5B,MAAMC,QAAQ;QACZ,IAAID,OAAOE,MAAM,KAAK,GAAG;YACvB;QACF;QACA,MAAMC,QAAQH;QACdA,SAAS,EAAE;QACX,IAAI;YACF,MAAMI,WAAW,MAAMZ,UAAUM,KAAK;gBACpCO,QAAQ;gBACRC,SAAS;oBAAE,gBAAgB;gBAAmB;gBAC9CrB,MAAMsB,KAAKC,SAAS,CAAC3C,kBAAkBsC,OAAOb,QAAQvB,WAAW;YACnE;YACA,IAAI,CAACqC,SAASK,EAAE,EAAE;gBAChBZ,QAAQ,IAAIa,MAAM,CAAC,yBAAyB,EAAEN,SAASO,MAAM,EAAE;YACjE;QACF,EAAE,OAAO/C,OAAO;YACdiC,QAAQjC;QACV;IACF;IAEA,IAAI0B,QAAQsB,eAAe,KAAKtD,WAAW;QACzC,MAAMuD,QAAQC,YAAY,IAAM,KAAKb,SAASX,QAAQsB,eAAe;QACrE,mDAAmD;QAClDC,MAAiCE,KAAK,oBAAvC,AAACF,MAAiCE,KAAK,MAAtCF;IACH;IAEA,OAAO;QACLG,MAAM,CAACzC;YACLyB,OAAOzC,IAAI,CAACgB;YACZ,IAAIyB,OAAOE,MAAM,IAAIX,WAAW;gBAC9B,KAAKU;YACP;QACF;QACAA;IACF;AACF,EAAE"}

package/dist/logging/sinks/stdout-json-sink.d.ts

@@ -0,0 +1,14 @@
+import type { LogSink } from '../types.js';
+/** Options for {@link makeStdoutJsonSink}. */
+export interface StdoutJsonSinkOptions {
+    /** Write seam (defaults to `process.stdout.write`); overridden in tests. */
+    readonly write?: (line: string) => void;
+}
+/**
+ * The production/backend sink: one JSON object per line on stdout. Crash-safe
+ * (no buffer to flush) and picked up by the OTel Collector's `filelog` receiver
+ * tailing `/var/log/pods`. This is the default in a cluster; dev uses the OTLP
+ * sink instead because a host-run `nx dev` process has no pod to tail.
+ */
+export declare const makeStdoutJsonSink: (options?: StdoutJsonSinkOptions) => LogSink;
+//# sourceMappingURL=stdout-json-sink.d.ts.map

package/dist/logging/sinks/stdout-json-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdout-json-sink.d.ts","sourceRoot":"","sources":["../../../src/logging/sinks/stdout-json-sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtD,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAS,qBAA0B,KAClC,OAOF,CAAC"}

package/dist/logging/sinks/stdout-json-sink.js

@@ -0,0 +1,16 @@
+/**
+ * The production/backend sink: one JSON object per line on stdout. Crash-safe
+ * (no buffer to flush) and picked up by the OTel Collector's `filelog` receiver
+ * tailing `/var/log/pods`. This is the default in a cluster; dev uses the OTLP
+ * sink instead because a host-run `nx dev` process has no pod to tail.
+ */ export const makeStdoutJsonSink = (options = {})=>{
+    var _options_write;
+    const write = (_options_write = options.write) != null ? _options_write : (line)=>process.stdout.write(line);
+    return {
+        emit: (record)=>{
+            write(`${JSON.stringify(record)}\n`);
+        }
+    };
+};
+
+//# sourceMappingURL=stdout-json-sink.js.map

package/dist/logging/sinks/stdout-json-sink.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/logging/sinks/stdout-json-sink.ts"],"sourcesContent":["import type { LogRecord, LogSink } from '../types.js';\n\n/** Options for {@link makeStdoutJsonSink}. */\nexport interface StdoutJsonSinkOptions {\n  /** Write seam (defaults to `process.stdout.write`); overridden in tests. */\n  readonly write?: (line: string) => void;\n}\n\n/**\n * The production/backend sink: one JSON object per line on stdout. Crash-safe\n * (no buffer to flush) and picked up by the OTel Collector's `filelog` receiver\n * tailing `/var/log/pods`. This is the default in a cluster; dev uses the OTLP\n * sink instead because a host-run `nx dev` process has no pod to tail.\n */\nexport const makeStdoutJsonSink = (\n  options: StdoutJsonSinkOptions = {},\n): LogSink => {\n  const write = options.write ?? (line => process.stdout.write(line));\n  return {\n    emit: (record: LogRecord) => {\n      write(`${JSON.stringify(record)}\\n`);\n    },\n  };\n};\n"],"names":["makeStdoutJsonSink","options","write","line","process","stdout","emit","record","JSON","stringify"],"mappings":"AAQA;;;;;CAKC,GACD,OAAO,MAAMA,qBAAqB,CAChCC,UAAiC,CAAC,CAAC;QAErBA;IAAd,MAAMC,SAAQD,iBAAAA,QAAQC,KAAK,YAAbD,iBAAkBE,CAAAA,OAAQC,QAAQC,MAAM,CAACH,KAAK,CAACC;IAC7D,OAAO;QACLG,MAAM,CAACC;YACLL,MAAM,GAAGM,KAAKC,SAAS,CAACF,QAAQ,EAAE,CAAC;QACrC;IACF;AACF,EAAE"}

package/dist/logging/types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The logging facade's public shape. Framework-free on purpose: the same
+ * interface serves Effect backends, the Next server runtime, and the browser,
+ * because it is built on the OpenTelemetry log-record model rather than on any
+ * one framework's logger. See `docs/ARCHITECTURE.md` (Observability & tooling).
+ */
+/** The four log levels the platform uses, in ascending severity. */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/** A single structured attribute value. `undefined` keys are dropped by JSON. */
+export type AttributeValue = string | number | boolean | null;
+/** Structured key/value context attached to a log line. */
+export interface Attributes {
+    readonly [key: string]: AttributeValue | undefined;
+}
+/** An error flattened to a serializable shape (never a live `Error` instance). */
+export interface SerializedError {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+}
+/**
+ * One structured log record. This is the wire shape every sink receives; it
+ * mirrors the OpenTelemetry LogRecord (severity number, body, attributes,
+ * trace/span correlation) so a sink can forward it as OTLP unchanged.
+ */
+export interface LogRecord {
+    /** ISO-8601 timestamp. */
+    readonly timestamp: string;
+    readonly level: LogLevel;
+    /** OTel `SeverityNumber` for {@link level}. */
+    readonly severityNumber: number;
+    /** Emitting service name (`service.name`). */
+    readonly service: string;
+    readonly message: string;
+    readonly attributes: Attributes;
+    /** Present only when a span is active — this is the trace-correlation link. */
+    readonly traceId?: string;
+    readonly spanId?: string;
+    readonly error?: SerializedError;
+}
+/**
+ * A transport for log records. The seam that keeps the package portable: the
+ * backend uses a stdout-JSON sink (tailed by the Collector's filelog receiver),
+ * the browser an HTTP sink to `/api/telemetry`, dev an OTLP sink to otel-lgtm.
+ */
+export interface LogSink {
+    emit(record: LogRecord): void;
+}
+/** The leveled logger applications call. */
+export interface Logger {
+    debug(message: string, attributes?: Attributes): void;
+    info(message: string, attributes?: Attributes): void;
+    warn(message: string, attributes?: Attributes): void;
+    /** `error` carries an optional cause alongside the structured attributes. */
+    error(message: string, error?: unknown, attributes?: Attributes): void;
+    /** Returns a logger that stamps every record with `bindings` (e.g. per-request). */
+    child(bindings: Attributes): Logger;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/logging/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,oEAAoE;AACpE,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE9D,2DAA2D;AAC3D,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;CACpD;AAED,kFAAkF;AAClF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,0BAA0B;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,+CAA+C;IAC/C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAC/B;AAED,4CAA4C;AAC5C,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACtD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACrD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACrD,6EAA6E;IAC7E,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACvE,oFAAoF;IACpF,KAAK,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC;CACrC"}

package/dist/logging/types.js

@@ -0,0 +1,8 @@
+/**
+ * The logging facade's public shape. Framework-free on purpose: the same
+ * interface serves Effect backends, the Next server runtime, and the browser,
+ * because it is built on the OpenTelemetry log-record model rather than on any
+ * one framework's logger. See `docs/ARCHITECTURE.md` (Observability & tooling).
+ */ /** The four log levels the platform uses, in ascending severity. */ /** The leveled logger applications call. */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/logging/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging/types.ts"],"sourcesContent":["/**\n * The logging facade's public shape. Framework-free on purpose: the same\n * interface serves Effect backends, the Next server runtime, and the browser,\n * because it is built on the OpenTelemetry log-record model rather than on any\n * one framework's logger. See `docs/ARCHITECTURE.md` (Observability & tooling).\n */\n\n/** The four log levels the platform uses, in ascending severity. */\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error';\n\n/** A single structured attribute value. `undefined` keys are dropped by JSON. */\nexport type AttributeValue = string | number | boolean | null;\n\n/** Structured key/value context attached to a log line. */\nexport interface Attributes {\n  readonly [key: string]: AttributeValue | undefined;\n}\n\n/** An error flattened to a serializable shape (never a live `Error` instance). */\nexport interface SerializedError {\n  readonly name: string;\n  readonly message: string;\n  readonly stack?: string;\n}\n\n/**\n * One structured log record. This is the wire shape every sink receives; it\n * mirrors the OpenTelemetry LogRecord (severity number, body, attributes,\n * trace/span correlation) so a sink can forward it as OTLP unchanged.\n */\nexport interface LogRecord {\n  /** ISO-8601 timestamp. */\n  readonly timestamp: string;\n  readonly level: LogLevel;\n  /** OTel `SeverityNumber` for {@link level}. */\n  readonly severityNumber: number;\n  /** Emitting service name (`service.name`). */\n  readonly service: string;\n  readonly message: string;\n  readonly attributes: Attributes;\n  /** Present only when a span is active — this is the trace-correlation link. */\n  readonly traceId?: string;\n  readonly spanId?: string;\n  readonly error?: SerializedError;\n}\n\n/**\n * A transport for log records. The seam that keeps the package portable: the\n * backend uses a stdout-JSON sink (tailed by the Collector's filelog receiver),\n * the browser an HTTP sink to `/api/telemetry`, dev an OTLP sink to otel-lgtm.\n */\nexport interface LogSink {\n  emit(record: LogRecord): void;\n}\n\n/** The leveled logger applications call. */\nexport interface Logger {\n  debug(message: string, attributes?: Attributes): void;\n  info(message: string, attributes?: Attributes): void;\n  warn(message: string, attributes?: Attributes): void;\n  /** `error` carries an optional cause alongside the structured attributes. */\n  error(message: string, error?: unknown, attributes?: Attributes): void;\n  /** Returns a logger that stamps every record with `bindings` (e.g. per-request). */\n  child(bindings: Attributes): Logger;\n}\n"],"names":[],"mappings":"AAAA;;;;;CAKC,GAED,kEAAkE,GAgDlE,0CAA0C,GAC1C,WAQC"}

package/dist/tracking/index.d.ts

@@ -0,0 +1,3 @@
+export * from './noop-tracker.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tracking/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC"}

package/dist/tracking/index.js

@@ -0,0 +1,4 @@
+export * from './noop-tracker.js';
+export * from './types.js';
+
+//# sourceMappingURL=index.js.map

package/dist/tracking/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tracking/index.ts"],"sourcesContent":["export * from './noop-tracker.js';\nexport * from './types.js';\n"],"names":[],"mappings":"AAAA,cAAc,oBAAoB;AAClC,cAAc,aAAa"}

package/dist/tracking/noop-tracker.d.ts

@@ -0,0 +1,8 @@
+import type { Tracker } from './types.js';
+/**
+ * A {@link Tracker} that discards everything and resolves every flag to `false`.
+ * The safe default before a real adapter (PostHog) is wired into a composition
+ * root — code can depend on `Tracker` without a vendor being present yet.
+ */
+export declare const NoopTracker: Tracker;
+//# sourceMappingURL=noop-tracker.d.ts.map

package/dist/tracking/noop-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop-tracker.d.ts","sourceRoot":"","sources":["../../src/tracking/noop-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,OAIzB,CAAC"}

package/dist/tracking/noop-tracker.js

@@ -0,0 +1,11 @@
+/**
+ * A {@link Tracker} that discards everything and resolves every flag to `false`.
+ * The safe default before a real adapter (PostHog) is wired into a composition
+ * root — code can depend on `Tracker` without a vendor being present yet.
+ */ export const NoopTracker = {
+    track: ()=>undefined,
+    identify: ()=>undefined,
+    flag: ()=>false
+};
+
+//# sourceMappingURL=noop-tracker.js.map

package/dist/tracking/noop-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tracking/noop-tracker.ts"],"sourcesContent":["import type { Tracker } from './types.js';\n\n/**\n * A {@link Tracker} that discards everything and resolves every flag to `false`.\n * The safe default before a real adapter (PostHog) is wired into a composition\n * root — code can depend on `Tracker` without a vendor being present yet.\n */\nexport const NoopTracker: Tracker = {\n  track: () => undefined,\n  identify: () => undefined,\n  flag: () => false,\n};\n"],"names":["NoopTracker","track","undefined","identify","flag"],"mappings":"AAEA;;;;CAIC,GACD,OAAO,MAAMA,cAAuB;IAClCC,OAAO,IAAMC;IACbC,UAAU,IAAMD;IAChBE,MAAM,IAAM;AACd,EAAE"}

package/dist/tracking/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The product-analytics facade. Deliberately NOT sharing an interface with
+ * logging: tracking is a different concern (business events + experiments for
+ * PMs/growth, long-retained and user-identified) that fans out to a different
+ * backend (PostHog), unlike observability logs. Same package, separate module.
+ *
+ * A real adapter (see `@entifix/posthog`) implements this
+ * interface; it is provided per environment behind `TrackerTag` (Effect
+ * `Context.Tag`, in `@entifix/business`) — the browser and backend both
+ * run Effect DI, so the same seam works in each.
+ */
+/** A single tracked-property value. */
+export type PropertyValue = string | number | boolean | null;
+/** Structured properties attached to an event or identity. */
+export interface Props {
+    readonly [key: string]: PropertyValue | undefined;
+}
+/** The product-analytics + feature-flag surface applications call. */
+export interface Tracker {
+    /** Record a business event, e.g. `track('checkout_started', { cartValue })`. */
+    track(event: string, props?: Props): void;
+    /** Associate the current actor with an id (+ optional traits). */
+    identify(id: string, traits?: Props): void;
+    /** Resolve a feature flag / experiment variant for `key`. */
+    flag(key: string): boolean | string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tracking/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uCAAuC;AACvC,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE7D,8DAA8D;AAC9D,MAAM,WAAW,KAAK;IACpB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;CACnD;AAED,sEAAsE;AACtE,MAAM,WAAW,OAAO;IACtB,gFAAgF;IAChF,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAC1C,kEAAkE;IAClE,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAC3C,6DAA6D;IAC7D,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CACrC"}

package/dist/tracking/types.js

@@ -0,0 +1,13 @@
+/**
+ * The product-analytics facade. Deliberately NOT sharing an interface with
+ * logging: tracking is a different concern (business events + experiments for
+ * PMs/growth, long-retained and user-identified) that fans out to a different
+ * backend (PostHog), unlike observability logs. Same package, separate module.
+ *
+ * A real adapter (see `@entifix/posthog`) implements this
+ * interface; it is provided per environment behind `TrackerTag` (Effect
+ * `Context.Tag`, in `@entifix/business`) — the browser and backend both
+ * run Effect DI, so the same seam works in each.
+ */ /** A single tracked-property value. */ /** The product-analytics + feature-flag surface applications call. */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/tracking/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tracking/types.ts"],"sourcesContent":["/**\n * The product-analytics facade. Deliberately NOT sharing an interface with\n * logging: tracking is a different concern (business events + experiments for\n * PMs/growth, long-retained and user-identified) that fans out to a different\n * backend (PostHog), unlike observability logs. Same package, separate module.\n *\n * A real adapter (see `@entifix/posthog`) implements this\n * interface; it is provided per environment behind `TrackerTag` (Effect\n * `Context.Tag`, in `@entifix/business`) — the browser and backend both\n * run Effect DI, so the same seam works in each.\n */\n\n/** A single tracked-property value. */\nexport type PropertyValue = string | number | boolean | null;\n\n/** Structured properties attached to an event or identity. */\nexport interface Props {\n  readonly [key: string]: PropertyValue | undefined;\n}\n\n/** The product-analytics + feature-flag surface applications call. */\nexport interface Tracker {\n  /** Record a business event, e.g. `track('checkout_started', { cartValue })`. */\n  track(event: string, props?: Props): void;\n  /** Associate the current actor with an id (+ optional traits). */\n  identify(id: string, traits?: Props): void;\n  /** Resolve a feature flag / experiment variant for `key`. */\n  flag(key: string): boolean | string;\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,qCAAqC,GAQrC,oEAAoE,GACpE,WAOC"}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@entifix/tooling",
+  "version": "0.1.0-0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/ts/tooling"
+  },
+  "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"
+    },
+    "./logging": {
+      "@entifix/source": "./src/logging/index.ts",
+      "types": "./dist/logging/index.d.ts",
+      "import": "./dist/logging/index.js",
+      "default": "./dist/logging/index.js"
+    },
+    "./tracking": {
+      "@entifix/source": "./src/tracking/index.ts",
+      "types": "./dist/tracking/index.d.ts",
+      "import": "./dist/tracking/index.js",
+      "default": "./dist/tracking/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "nx": {
+    "tags": [
+      "layer:entifix",
+      "scope:shared",
+      "entifix:tooling",
+      "tier:0"
+    ],
+    "sourceRoot": "packages/ts/tooling/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/ts/tooling/dist",
+          "main": "packages/ts/tooling/src/index.ts",
+          "tsConfig": "packages/ts/tooling/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.23"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9 <2"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "1.9.1"
+  }
+}