@vibesdotdev/logging 0.0.1 → 1.0.0-rc.4

package/dist/kinds/file-output.js

@@ -0,0 +1,11 @@
+/**
+ * The typed file-output contract (C092).
+ *
+ * The `logging/output` descriptor with id `file` is the file-storage backend a
+ * host package implements (`@vibesdotdev/host-node/logging`).
+ * Callers resolve it by id with these generics and call its required methods:
+ * no `instanceof`, no optional-method presence checks.
+ */
+/** The `logging/output` id of the file-storage backend. */
+export const FILE_OUTPUT_ID = 'file';
+//# sourceMappingURL=file-output.js.map

package/dist/kinds/file-output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-output.js","sourceRoot":"","sources":["../../src/kinds/file-output.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,2DAA2D;AAC3D,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC"}

package/dist/kinds/formatter.d.ts

@@ -3,9 +3,9 @@
  *
  * Formatters serialize log entries to various output formats.
  */
-import type { RuntimeKindDescriptor, KindContext } from '@vibesdotdev/runtime/schemas/kind';
+import type { RuntimeKindDescriptor, KindContext } from '@vibesdotdev/kernel/schemas/kind';
 import { type FormatterDescriptor } from '../schemas/formatter.ts';
-import type { RuntimeLogEntry } from '../schemas/entry.ts';
+import { type RuntimeLogEntry } from '../schemas/entry.ts';
 /**
  * Formatter implementation interface.
  * Implementations convert log entries to/from string representation.
@@ -24,15 +24,13 @@ export interface FormatterImplementation {
  * Context provided to formatter implementations.
  */
 export interface FormatterContext extends KindContext {
-    /** Runtime reference */
-    readonly runtime: unknown;
 }
 /**
  * Formatter kind definition for runtime registration.
  */
 export declare const formatterKind: RuntimeKindDescriptor<FormatterDescriptor, FormatterImplementation, FormatterContext>;
-declare module '@vibesdotdev/runtime/schemas/kind-types' {
-    interface KindTypeMap {
+declare global {
+    interface VibesKindTypeMap {
         'logging/formatter': {
             descriptor: FormatterDescriptor;
             impl: FormatterImplementation;

package/dist/kinds/formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/kinds/formatter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAqB,MAAM,mCAAmC,CAAC;AAE/G,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACvC,gCAAgC;IAChC,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAAC;IACvC,iDAAiD;IACjD,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,CAAC;IAC1C,mDAAmD;IACnD,WAAW,CAAC,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAAC;IACjD,uCAAuC;IACvC,UAAU,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CAAC;CAClD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,wBAAwB;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC1B;AAiED;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAChD,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,CAOhB,CAAC;AAEF,OAAO,QAAQ,yCAAyC,CAAC;IACxD,UAAU,WAAW;QACpB,mBAAmB,EAAE;YAAE,UAAU,EAAE,mBAAmB,CAAC;YAAC,IAAI,EAAE,uBAAuB,CAAA;SAAE,CAAC;KACxF;CACD"}
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/kinds/formatter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAqB,MAAM,kCAAkC,CAAC;AAE9G,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9F,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAElF;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACvC,gCAAgC;IAChC,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAAC;IACvC,iDAAiD;IACjD,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,CAAC;IAC1C,mDAAmD;IACnD,WAAW,CAAC,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAAC;IACjD,uCAAuC;IACvC,UAAU,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CAAC;CAClD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,WAAW;CACpD;AAiED;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAChD,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,CAOhB,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,gBAAgB;QACzB,mBAAmB,EAAE;YAAE,UAAU,EAAE,mBAAmB,CAAC;YAAC,IAAI,EAAE,uBAAuB,CAAA;SAAE,CAAC;KACxF;CACD"}

package/dist/kinds/formatter.js

@@ -4,6 +4,7 @@
  * Formatters serialize log entries to various output formats.
  */
 import { FormatterDescriptorSchema } from "../schemas/formatter.js";
+import { RuntimeLogEntrySchema } from "../schemas/entry.js";
 /**
  * Default formatter implementation - JSON output.
  * Used when no specific implementation is registered.
@@ -13,13 +14,13 @@ class DefaultFormatterImplementation {
     descriptor;
     constructor(descriptor, _context) {
         this.id = descriptor.id;
-        this.descriptor = descriptor;
+        this.descriptor = FormatterDescriptorSchema.parse(descriptor);
     }
     format(entry) {
         return JSON.stringify(entry);
     }
     parse(formatted) {
-        return JSON.parse(formatted);
+        return RuntimeLogEntrySchema.parse(JSON.parse(formatted));
     }
     formatBatch(entries) {
         return entries.map((e) => this.format(e)).join('\n');
@@ -36,7 +37,7 @@ class DefaultFormatterImplementation {
  * Selects formatter based on format and hardware.
  */
 function resolveFormatter(candidates, scope, _context) {
-    const typed = candidates;
+    const typed = FormatterDescriptorSchema.array().parse(candidates);
     if (typed.length === 0)
         return undefined;
     if (typed.length === 1)

package/dist/kinds/formatter.js.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.js","sourceRoot":"","sources":["../../src/kinds/formatter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,yBAAyB,EAA4B,MAAM,yBAAyB,CAAC;AA0B9F;;;GAGG;AACH,MAAM,8BAA8B;IAC1B,EAAE,CAAS;IACX,UAAU,CAAsB;IAEzC,YAAY,UAA6B,EAAE,QAA0B;QACpE,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,UAAiC,CAAC;IACrD,CAAC;IAED,MAAM,CAAC,KAAsB;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,SAAiB;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAoB,CAAC;IACjD,CAAC;IAED,WAAW,CAAC,OAA0B;QACrC,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAED,UAAU,CAAC,SAAiB;QAC3B,OAAO,SAAS;aACd,KAAK,CAAC,IAAI,CAAC;aACX,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;aAC7B,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC;CACD;AAED;;;GAGG;AACH,SAAS,gBAAgB,CACxB,UAA+B,EAC/B,KAAmB,EACnB,QAAqB;IAErB,MAAM,KAAK,GAAG,UAAmC,CAAC;IAClD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAExC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IAEhC,mCAAmC;IACnC,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QACnC,IAAI,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACxD,OAAO,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAE5C,iDAAiD;IACjD,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7E,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE5C,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAItB;IACH,EAAE,EAAE,mBAAmB;IACvB,gBAAgB,EAAE,yBAAyB;IAC3C,qBAAqB,EAAE,8BAA8B;IACrD,OAAO,EAAE,gBAAgB;IACzB,QAAQ,EAAE,EAAE;CACZ,CAAC"}
+{"version":3,"file":"formatter.js","sourceRoot":"","sources":["../../src/kinds/formatter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,yBAAyB,EAA4B,MAAM,yBAAyB,CAAC;AAC9F,OAAO,EAAE,qBAAqB,EAAwB,MAAM,qBAAqB,CAAC;AAuBlF;;;GAGG;AACH,MAAM,8BAA8B;IAC1B,EAAE,CAAS;IACX,UAAU,CAAsB;IAEzC,YAAY,UAA6B,EAAE,QAA0B;QACpE,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,yBAAyB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,CAAC,KAAsB;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,SAAiB;QACtB,OAAO,qBAAqB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,WAAW,CAAC,OAA0B;QACrC,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAED,UAAU,CAAC,SAAiB;QAC3B,OAAO,SAAS;aACd,KAAK,CAAC,IAAI,CAAC;aACX,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;aAC7B,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC;CACD;AAED;;;GAGG;AACH,SAAS,gBAAgB,CACxB,UAA+B,EAC/B,KAAmB,EACnB,QAAqB;IAErB,MAAM,KAAK,GAAG,yBAAyB,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAClE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAExC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IAEhC,mCAAmC;IACnC,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QACnC,IAAI,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACxD,OAAO,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAE5C,iDAAiD;IACjD,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7E,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE5C,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAItB;IACH,EAAE,EAAE,mBAAmB;IACvB,gBAAgB,EAAE,yBAAyB;IAC3C,qBAAqB,EAAE,8BAA8B;IACrD,OAAO,EAAE,gBAAgB;IACzB,QAAQ,EAAE,EAAE;CACZ,CAAC"}

package/dist/kinds/index.d.ts

@@ -1,13 +1,13 @@
 import { sinkKind, type SinkImplementation, type SinkContext } from './sink.ts';
 import { formatterKind, type FormatterImplementation, type FormatterContext } from './formatter.ts';
 import { outputKind, type OutputImplementation, type OutputContext } from './output.ts';
-import { auditKind, type AuditImplementation, type AuditContext, type AuditLogInput, type AuditQueryOptions } from './audit.ts';
+import { auditKind, type AuditImplementation, type AuditContext, type AuditLogInput, type AuditQueryOptions, auditLog, buildAuditEntry, emitAuditEntry, redactAuditContext } from './audit.ts';
 import { loggerKind } from './logger.ts';
-import DefaultLoggerImplementation, { type LoggerImplementation, type LoggerContext } from './logger.impl';
+import DefaultLoggerImplementation, { type LoggerImplementation, type LoggerContext } from './logger.impl.ts';
 export { sinkKind, type SinkImplementation, type SinkContext };
 export { formatterKind, type FormatterImplementation, type FormatterContext };
 export { outputKind, type OutputImplementation, type OutputContext };
-export { auditKind, type AuditImplementation, type AuditContext, type AuditLogInput, type AuditQueryOptions };
+export { auditKind, type AuditImplementation, type AuditContext, type AuditLogInput, type AuditQueryOptions, auditLog, buildAuditEntry, emitAuditEntry, redactAuditContext };
 export { loggerKind };
 export { DefaultLoggerImplementation, type LoggerImplementation, type LoggerContext };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kinds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,KAAK,uBAAuB,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACpG,OAAO,EAAE,UAAU,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACxF,OAAO,EACN,SAAS,EACT,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,2BAA2B,EAAE,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAE3G,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,KAAK,uBAAuB,EAAE,KAAK,gBAAgB,EAAE,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,CAAC;AACrE,OAAO,EACN,SAAS,EACT,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,CAAC;AACF,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,OAAO,EAAE,2BAA2B,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kinds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,KAAK,uBAAuB,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACpG,OAAO,EAAE,UAAU,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACxF,OAAO,EACN,SAAS,EACT,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,QAAQ,EACR,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,2BAA2B,EAAE,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE9G,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,KAAK,uBAAuB,EAAE,KAAK,gBAAgB,EAAE,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,CAAC;AACrE,OAAO,EACN,SAAS,EACT,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,QAAQ,EACR,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,CAAC;AACF,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,OAAO,EAAE,2BAA2B,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,CAAC"}

package/dist/kinds/index.js

@@ -1,13 +1,13 @@
 import { sinkKind } from "./sink.js";
 import { formatterKind } from "./formatter.js";
 import { outputKind } from "./output.js";
-import { auditKind } from "./audit.js";
+import { auditKind, auditLog, buildAuditEntry, emitAuditEntry, redactAuditContext } from "./audit.js";
 import { loggerKind } from "./logger.js";
-import DefaultLoggerImplementation, {} from './logger.impl.js';
+import DefaultLoggerImplementation, {} from "./logger.impl.js";
 export { sinkKind };
 export { formatterKind };
 export { outputKind };
-export { auditKind };
+export { auditKind, auditLog, buildAuditEntry, emitAuditEntry, redactAuditContext };
 export { loggerKind };
 export { DefaultLoggerImplementation };
 //# sourceMappingURL=index.js.map

package/dist/kinds/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/kinds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA6C,MAAM,WAAW,CAAC;AAChF,OAAO,EAAE,aAAa,EAAuD,MAAM,gBAAgB,CAAC;AACpG,OAAO,EAAE,UAAU,EAAiD,MAAM,aAAa,CAAC;AACxF,OAAO,EACN,SAAS,EAKT,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,2BAA2B,EAAE,EAAiD,MAAM,eAAe,CAAC;AAE3G,OAAO,EAAE,QAAQ,EAA6C,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAuD,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAiD,CAAC;AACrE,OAAO,EACN,SAAS,EAKT,CAAC;AACF,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,OAAO,EAAE,2BAA2B,EAAiD,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/kinds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA6C,MAAM,WAAW,CAAC;AAChF,OAAO,EAAE,aAAa,EAAuD,MAAM,gBAAgB,CAAC;AACpG,OAAO,EAAE,UAAU,EAAiD,MAAM,aAAa,CAAC;AACxF,OAAO,EACN,SAAS,EAKT,QAAQ,EACR,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,2BAA2B,EAAE,EAAiD,MAAM,kBAAkB,CAAC;AAE9G,OAAO,EAAE,QAAQ,EAA6C,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAuD,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAiD,CAAC;AACrE,OAAO,EACN,SAAS,EAKT,QAAQ,EACR,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,CAAC;AACF,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,OAAO,EAAE,2BAA2B,EAAiD,CAAC"}

package/dist/kinds/logger.d.ts

@@ -1,11 +1,11 @@
-import type { RuntimeKindDescriptor } from '@vibesdotdev/runtime/schemas/kind';
+import type { RuntimeKindDescriptor } from '@vibesdotdev/kernel/schemas/kind';
 import { type LoggerDescriptor } from '../schemas/logger.ts';
-import { type LoggerImplementation } from './logger.impl';
+import { type LoggerImplementation } from './logger.impl.ts';
 import type { LoggerContext } from './contexts.ts';
 export type { LoggerImplementation, LoggerContext };
 export declare const loggerKind: RuntimeKindDescriptor<LoggerDescriptor, LoggerImplementation, LoggerContext>;
-declare module '@vibesdotdev/runtime/schemas/kind-types' {
-    interface KindTypeMap {
+declare global {
+    interface VibesKindTypeMap {
         'logging/logger': {
             descriptor: LoggerDescriptor;
             impl: LoggerImplementation;

package/dist/kinds/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/kinds/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAkC,MAAM,mCAAmC,CAAC;AAE/G,OAAO,EAA0B,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACrF,OAAoC,EAAE,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,CAAC;AAuBpD,eAAO,MAAM,UAAU,EAAE,qBAAqB,CAC7C,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,CAOb,CAAC;AAEF,OAAO,QAAQ,yCAAyC,CAAC;IACxD,UAAU,WAAW;QACpB,gBAAgB,EAAE;YAAE,UAAU,EAAE,gBAAgB,CAAC;YAAC,IAAI,EAAE,oBAAoB,CAAA;SAAE,CAAC;KAC/E;CACD"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/kinds/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAkC,MAAM,kCAAkC,CAAC;AAE9G,OAAO,EAA8D,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACzH,OAAoC,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,CAAC;AAyBpD,eAAO,MAAM,UAAU,EAAE,qBAAqB,CAC7C,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,CAcb,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,gBAAgB;QACzB,gBAAgB,EAAE;YAAE,UAAU,EAAE,gBAAgB,CAAC;YAAC,IAAI,EAAE,oBAAoB,CAAA;SAAE,CAAC;KAC/E;CACD"}

package/dist/kinds/logger.impl.d.ts

@@ -1,15 +1,25 @@
 import type { LogContext, LoggerChildOptions, RequestLogContext, JobLogContext, PerformanceTrackerParams, PerformanceTracker } from '../schemas/entry.ts';
 export type { PerformanceTracker } from '../schemas/entry.ts';
-import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/kind';
-import type { KindContext } from '@vibesdotdev/runtime/schemas/kind';
+import type { SinkImplementation } from './sink.ts';
+import { type LogMethod } from '../core/normalize.ts';
+import type { LoggedError } from '../core/redact.ts';
+import type { RuntimeDescriptor } from '@vibesdotdev/kernel/schemas/kind';
+import type { KindContext } from '@vibesdotdev/kernel/schemas/kind';
 export type { LoggerContext } from './contexts.ts';
+interface PreparedBackends {
+    readonly fallback: SinkImplementation;
+    readonly diagnostics: LoggerImplementation;
+    assertLive(): void;
+    /** Join an accepted write; its failure goes to `recover`, and a failed recovery is retained for close. */
+    accept(operation: Promise<void>, recover: (failure: LoggedError) => void): void;
+}
 export interface LoggerImplementation {
     readonly namespace: string;
     readonly fullNamespace: string;
-    debug(message: string, context?: unknown): void;
-    info(message: string, context?: unknown): void;
-    warn(message: string, context?: unknown): void;
-    error(message: string, context?: unknown): void;
+    debug: LogMethod;
+    info: LogMethod;
+    warn: LogMethod;
+    error: LogMethod;
     child(options: LoggerChildOptions): LoggerImplementation;
     withContext(context: LogContext): LoggerImplementation;
     withRequestContext(context: RequestLogContext): LoggerImplementation;
@@ -20,17 +30,34 @@ export default class DefaultLoggerImplementation implements LoggerImplementation
     readonly namespace: string;
     readonly fullNamespace: string;
     private readonly descriptor;
-    private readonly sinks;
-    private readonly outputs;
+    private sinks;
+    private outputs;
+    private readonly needsSinkBindings;
+    private readonly needsOutputBindings;
+    private backendsInitialized;
     private readonly staticMetadata;
-    constructor(descriptor: RuntimeDescriptor, context: KindContext, fullNamespace?: string, additionalMetadata?: LogContext);
+    private staticFailure;
+    private readonly runtime;
+    private backends;
+    constructor(descriptor: RuntimeDescriptor, context: KindContext, fullNamespace?: string, additionalMetadata?: LogContext, preparedBackends?: PreparedBackends);
+    /** Metadata that could not be read rides every entry as its `loggingError`; it is reported once, at the first emission. */
+    private reportStaticFailureOnce;
+    /** Runtime's kind hook awaits descriptor-owned providers before exposing the logger. */
+    initializeBackends(): Promise<void>;
     private getLevelSettings;
+    /** `readCall` reads the call's context; it runs only once the entry passed its level and sampling, so a dropped call never walks it. */
     private emit;
-    debug(message: string, context?: unknown): void;
-    info(message: string, context?: unknown): void;
-    warn(message: string, context?: unknown): void;
-    error(message: string, context?: unknown): void;
+    readonly debug: (args_0: string, args_1?: unknown, args_2?: unknown) => void;
+    readonly info: (args_0: string, args_1?: unknown, args_2?: unknown) => void;
+    readonly warn: (args_0: string, args_1?: unknown, args_2?: unknown) => void;
+    readonly error: (args_0: string, args_1?: unknown, args_2?: unknown) => void;
+    /**
+     * A logger derived from `merged` (read without throwing). A context that
+     * could not be read is reported once, here, and rides every entry the derived
+     * logger emits as its `loggingError`.
+     */
     private createContextualLogger;
+    /** The options are read once, without throwing; unreadable ones ride every entry as the `loggingError`, reported once here. */
     child(options: LoggerChildOptions): LoggerImplementation;
     withContext(context: LogContext): LoggerImplementation;
     withRequestContext(context: RequestLogContext): LoggerImplementation;

package/dist/kinds/logger.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.impl.d.ts","sourceRoot":"","sources":["../../src/kinds/logger.impl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEX,UAAU,EAEV,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACxB,kBAAkB,EAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAa9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAErE,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAInD,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAChD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAChD,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;IACzD,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,oBAAoB,CAAC;IACvD,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC;IACrE,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,oBAAoB,CAAC;IAC7D,kBAAkB,CAAC,MAAM,EAAE,wBAAwB,GAAG,kBAAkB,CAAC;CACzE;AAmBD,MAAM,CAAC,OAAO,OAAO,2BAA4B,YAAW,oBAAoB;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAa;gBAG3C,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,WAAW,EACpB,aAAa,CAAC,EAAE,MAAM,EACtB,kBAAkB,CAAC,EAAE,UAAU;IAehC,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,IAAI;IA6BZ,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAC/C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAC9C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAC9C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAE/C,OAAO,CAAC,sBAAsB;IAS9B,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB;IAUxD,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,oBAAoB;IAItD,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB;IAepE,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,oBAAoB;IAc5D,kBAAkB,CAAC,MAAM,EAAE,wBAAwB,GAAG,kBAAkB;CAsBxE"}
+{"version":3,"file":"logger.impl.d.ts","sourceRoot":"","sources":["../../src/kinds/logger.impl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEX,UAAU,EAEV,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACxB,kBAAkB,EAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAKpD,OAAO,EAA4B,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAYrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAOpE,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,UAAU,gBAAgB;IACzB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,UAAU,IAAI,IAAI,CAAC;IACnB,0GAA0G;IAC1G,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI,CAAC;CAChF;AA0CD,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;IACzD,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,oBAAoB,CAAC;IACvD,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC;IACrE,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,oBAAoB,CAAC;IAC7D,kBAAkB,CAAC,MAAM,EAAE,wBAAwB,GAAG,kBAAkB,CAAC;CACzE;AAED,MAAM,CAAC,OAAO,OAAO,2BAA4B,YAAW,oBAAoB;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;IAC5C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAU;IAC9C,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAa;IAC5C,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAA+B;gBAG9C,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,WAAW,EACpB,aAAa,CAAC,EAAE,MAAM,EACtB,kBAAkB,CAAC,EAAE,UAAU,EAC/B,gBAAgB,CAAC,EAAE,gBAAgB;IAoBpC,2HAA2H;IAC3H,OAAO,CAAC,uBAAuB;IAO/B,wFAAwF;IAClF,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBzC,OAAO,CAAC,gBAAgB;IAQxB,wIAAwI;IACxI,OAAO,CAAC,IAAI;IAiDZ,QAAQ,CAAC,KAAK,+DAAqM;IACnN,QAAQ,CAAC,IAAI,+DAAoM;IACjN,QAAQ,CAAC,IAAI,+DAAoM;IACjN,QAAQ,CAAC,KAAK,+DAAqM;IAEnN;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAW9B,+HAA+H;IAC/H,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB;IAKxD,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,oBAAoB;IAItD,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB;IAIpE,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,oBAAoB;IAI5D,kBAAkB,CAAC,MAAM,EAAE,wBAAwB,GAAG,kBAAkB;CAqBxE"}

package/dist/kinds/logger.impl.js

@@ -1,21 +1,58 @@
-import { shouldLog, getNamespaceSettings } from "../core/namespace.js";
-import { resolveSinkContext, resolveOutputContext, createDefaultConsoleSink, deriveChildConfig, resolveSinks, resolveOutputs } from './logger.utils.js';
-const defaultSink = createDefaultConsoleSink();
-function normalizeLogContext(context) {
-    if (context === undefined || context === null) {
-        return {};
-    }
-    if (context instanceof Error) {
-        return {
-            errorName: context.name,
-            errorMessage: context.message,
-            stack: context.stack
-        };
-    }
-    if (typeof context === 'object' && !Array.isArray(context)) {
-        return context;
-    }
-    return { value: context };
+import { LoggerDescriptorSchema } from "../schemas/logger.js";
+import { shouldLog, getNamespaceSettings, updateNamespaceSettingsFromRuntime } from "../core/namespace.js";
+import { captureLoggingConfig, getCapturedLoggingConfig } from "../config/load-config.js";
+import { shouldKeepLog } from "../observability/should-keep-log.js";
+import { PerformanceFailureSchema } from "../core/normalize.js";
+import { BackendFailureSchema, derivedLoggerMetadata, JOB_CONTEXT_FIELDS, LogCallSchema, mergeCallContextFields, mergeCallContexts, mergeFailureContexts, prepareEntryContext, OptionalCallContextSchema, readTrackerParams, REQUEST_CONTEXT_FIELDS } from "../core/entry-context.js";
+import { attempt, settle } from "../core/outcome.js";
+import { isLoggingEmissionClosed } from "../core/emission-window.js";
+import { resolveSinkContext, resolveOutputContext, createDefaultConsoleSink, deriveChildConfig, resolveSinks, resolveOutputs, reportBackendFailure } from "./logger.utils.js";
+import { CapabilityError, getRuntimeConsole } from '@vibesdotdev/kernel';
+import { createFallbackLogger } from "../contexts/fallback-logger.js";
+import { trackLoggingResource, untrackLoggingResource } from "../core/output-resources.js";
+async function prepareBackends(runtime) {
+    const fallback = createDefaultConsoleSink(await getRuntimeConsole(runtime));
+    const diagnostics = await createFallbackLogger('logging', runtime);
+    const lifecycle = runtime.lifecycle;
+    const accepted = new Set();
+    const failures = [];
+    let closing = false;
+    let closePromise;
+    const resource = {
+        close() {
+            if (closePromise)
+                return closePromise;
+            closing = true;
+            closePromise = (async () => {
+                await Promise.all(accepted);
+                untrackLoggingResource(runtime, resource);
+                if (failures.length)
+                    throw new AggregateError(failures, 'Logger backend diagnostics failed.');
+            })();
+            return closePromise;
+        }
+    };
+    trackLoggingResource(runtime, resource);
+    return {
+        fallback, diagnostics,
+        assertLive() {
+            if (closing || isLoggingEmissionClosed(runtime))
+                throw new CapabilityError('The logger no longer accepts entries.', 'CANCELLED', {
+                    reason: 'logger-runtime-disposed', cause: lifecycle.signal.reason
+                });
+        },
+        accept(operation, recover) {
+            const completed = settle(operation).then((written) => {
+                if (!written.failed)
+                    return;
+                const recovered = attempt(() => recover(BackendFailureSchema.parse(written.cause)));
+                if (recovered.failed)
+                    failures.push(BackendFailureSchema.parse(recovered.cause));
+            });
+            accepted.add(completed);
+            void completed.then(() => accepted.delete(completed));
+        }
+    };
 }
 export default class DefaultLoggerImplementation {
     namespace;
@@ -23,116 +60,171 @@ export default class DefaultLoggerImplementation {
     descriptor;
     sinks;
     outputs;
+    needsSinkBindings;
+    needsOutputBindings;
+    backendsInitialized = false;
     staticMetadata;
-    constructor(descriptor, context, fullNamespace, additionalMetadata) {
-        this.descriptor = descriptor;
-        this.namespace = descriptor.namespace;
-        this.fullNamespace = fullNamespace ?? descriptor.namespace;
-        const typedCtx = context;
-        this.sinks = resolveSinks(descriptor, resolveSinkContext(typedCtx), defaultSink);
-        this.outputs = resolveOutputs(descriptor, resolveOutputContext(typedCtx));
-        this.staticMetadata = {
-            runtime: descriptor.runtime,
-            ...descriptor.metadata,
-            ...additionalMetadata
-        };
+    staticFailure;
+    runtime;
+    backends;
+    constructor(descriptor, context, fullNamespace, additionalMetadata, preparedBackends) {
+        this.runtime = context.runtime;
+        this.backends = preparedBackends;
+        this.backendsInitialized = preparedBackends !== undefined;
+        this.descriptor = LoggerDescriptorSchema.parse(descriptor);
+        this.namespace = this.descriptor.namespace;
+        this.fullNamespace = fullNamespace ?? this.descriptor.namespace;
+        const sinks = resolveSinkContext(context);
+        const outputs = resolveOutputContext(context);
+        this.needsSinkBindings = sinks === undefined;
+        this.needsOutputBindings = outputs === undefined;
+        this.sinks = resolveSinks(this.descriptor, sinks, this.backends?.fallback);
+        this.outputs = resolveOutputs(this.descriptor, outputs);
+        // The static metadata is read (walked and redacted) once, here: each entry merges this snapshot with its call's.
+        const initial = mergeCallContexts({}, { runtime: this.descriptor.runtime, ...this.descriptor.metadata, ...additionalMetadata });
+        this.staticMetadata = derivedLoggerMetadata(initial);
+        this.staticFailure = initial.failure;
+    }
+    /** Metadata that could not be read rides every entry as its `loggingError`; it is reported once, at the first emission. */
+    reportStaticFailureOnce(backends) {
+        const failure = this.staticFailure;
+        if (failure === undefined)
+            return;
+        this.staticFailure = undefined;
+        backends.diagnostics.warn('Log context could not be normalized', { namespace: this.fullNamespace, error: failure });
+    }
+    /** Runtime's kind hook awaits descriptor-owned providers before exposing the logger. */
+    async initializeBackends() {
+        if (this.backendsInitialized)
+            return;
+        await captureLoggingConfig(this.runtime);
+        updateNamespaceSettingsFromRuntime(this.runtime);
+        this.backends = await prepareBackends(this.runtime);
+        if (!this.needsSinkBindings && this.sinks.length === 0)
+            this.sinks = [this.backends.fallback];
+        if (this.needsSinkBindings) {
+            const sinks = new Map();
+            for (const id of this.descriptor.sinks) {
+                sinks.set(id, await this.runtime.query('logging/sink').withId(id).resolve());
+            }
+            this.sinks = resolveSinks(this.descriptor, sinks, this.backends.fallback);
+        }
+        if (this.needsOutputBindings) {
+            const outputs = new Map();
+            for (const id of this.descriptor.outputs ?? []) {
+                outputs.set(id, await this.runtime.query('logging/output').withId(id).resolve());
+            }
+            this.outputs = resolveOutputs(this.descriptor, outputs);
+        }
+        this.backendsInitialized = true;
     }
     getLevelSettings() {
-        const base = getNamespaceSettings();
+        const base = getNamespaceSettings(this.runtime);
         if (this.descriptor.level && base.defaultLevel !== this.descriptor.level) {
             return { ...base, defaultLevel: this.descriptor.level };
         }
         return base;
     }
-    emit(level, message, context) {
+    /** `readCall` reads the call's context; it runs only once the entry passed its level and sampling, so a dropped call never walks it. */
+    emit(level, message, readCall) {
+        const backends = this.backends;
+        if (!this.backendsInitialized || !backends)
+            throw new CapabilityError('The logger has not been prepared by Runtime selection.', 'UNAVAILABLE', {
+                reason: 'logger-not-initialized', retryable: false
+            });
+        backends.assertLive();
         const settings = this.getLevelSettings();
         if (!shouldLog({ namespace: this.fullNamespace, level, settings }))
             return;
+        const infoRate = getCapturedLoggingConfig(this.runtime).infoSamplingRate;
+        // LogLevel ('debug'|'info'|'warn'|'error') is a subset of SampledLogLevel,
+        // which additionally carries 'fatal'. The guard this replaced enumerated
+        // every LogLevel member plus 'fatal' and fell back to 'info' — but no
+        // LogLevel value can miss that list, so the fallback was unreachable and
+        // the 'fatal' arm compared two types with no overlap. Passing `level`
+        // straight through is the same behavior with the dead branches gone.
+        if (!shouldKeepLog(level, infoRate)) {
+            return;
+        }
+        this.reportStaticFailureOnce(backends);
+        const prepared = prepareEntryContext(this.staticMetadata, readCall());
         const entry = {
             timestamp: new Date().toISOString(),
             level,
             namespace: this.fullNamespace,
             message,
-            context: { ...this.staticMetadata, ...normalizeLogContext(context) }
+            context: prepared.context
+        };
+        // The entry is still delivered; the failure is reported once, with its namespace and level.
+        if (prepared.failure)
+            backends.diagnostics.warn('Log context could not be normalized', { namespace: this.fullNamespace, level, error: prepared.failure });
+        const recoverSink = (failure) => {
+            backends.fallback.emit(entry);
+            reportBackendFailure(backends.diagnostics, 'sink', failure);
         };
         for (const sink of this.sinks) {
-            try {
-                sink.emit(entry);
-            }
-            catch (e) {
-                defaultSink.emit(entry);
-            }
+            const emitted = attempt(() => sink.emit(entry));
+            if (emitted.failed)
+                recoverSink(BackendFailureSchema.parse(emitted.cause));
+            else if (emitted.value)
+                backends.accept(emitted.value, recoverSink);
         }
+        const recoverOutput = (failure) => reportBackendFailure(backends.diagnostics, 'output', failure);
         for (const output of this.outputs) {
-            try {
-                output.write(entry).catch(() => { });
-            }
-            catch {
-                /* output sync error */
-            }
+            const written = attempt(() => output.write(entry));
+            if (written.failed)
+                recoverOutput(BackendFailureSchema.parse(written.cause));
+            else
+                backends.accept(written.value, recoverOutput);
         }
     }
-    debug(message, context) { this.emit('debug', message, context); }
-    info(message, context) { this.emit('info', message, context); }
-    warn(message, context) { this.emit('warn', message, context); }
-    error(message, context) { this.emit('error', message, context); }
-    createContextualLogger(merged) {
-        return new DefaultLoggerImplementation(this.descriptor, { runtime: undefined, sinks: this.sinks, outputs: this.outputs }, this.fullNamespace, merged);
+    debug = LogCallSchema.implement((message, context, extra) => this.emit('debug', message, () => (extra === undefined ? OptionalCallContextSchema.parse(context) : mergeCallContexts({}, context, extra))));
+    info = LogCallSchema.implement((message, context, extra) => this.emit('info', message, () => (extra === undefined ? OptionalCallContextSchema.parse(context) : mergeCallContexts({}, context, extra))));
+    warn = LogCallSchema.implement((message, context, extra) => this.emit('warn', message, () => (extra === undefined ? OptionalCallContextSchema.parse(context) : mergeCallContexts({}, context, extra))));
+    error = LogCallSchema.implement((message, context, extra) => this.emit('error', message, () => (extra === undefined ? OptionalCallContextSchema.parse(context) : mergeCallContexts({}, context, extra))));
+    /**
+     * A logger derived from `merged` (read without throwing). A context that
+     * could not be read is reported once, here, and rides every entry the derived
+     * logger emits as its `loggingError`.
+     */
+    createContextualLogger(merged, fullNamespace = this.fullNamespace) {
+        if (merged.failure)
+            this.backends?.diagnostics.warn('Log context could not be normalized', { namespace: this.fullNamespace, error: merged.failure });
+        return new DefaultLoggerImplementation(this.descriptor, { runtime: this.runtime, sinks: this.sinks, outputs: this.outputs }, fullNamespace, derivedLoggerMetadata(merged), this.backends);
     }
+    /** The options are read once, without throwing; unreadable ones ride every entry as the `loggingError`, reported once here. */
     child(options) {
-        const { nextNamespace, childMetadata } = deriveChildConfig(this.fullNamespace, options);
-        return new DefaultLoggerImplementation(this.descriptor, { runtime: undefined, sinks: this.sinks, outputs: this.outputs }, nextNamespace, { ...this.staticMetadata, ...childMetadata });
+        const { nextNamespace, childMetadata, failure } = deriveChildConfig(this.fullNamespace, options);
+        return this.createContextualLogger({ context: { ...this.staticMetadata, ...childMetadata }, failure }, nextNamespace);
     }
     withContext(context) {
-        return this.createContextualLogger({ ...this.staticMetadata, ...context });
+        return this.createContextualLogger(mergeCallContexts(this.staticMetadata, context));
     }
     withRequestContext(context) {
-        const s = this.staticMetadata;
-        return this.createContextualLogger({
-            ...s,
-            requestId: context.requestId ?? s.requestId,
-            correlationId: context.correlationId ?? s.correlationId,
-            sessionId: context.sessionId ?? s.sessionId,
-            userId: context.userId ?? s.userId,
-            userAgent: context.userAgent ?? s.userAgent,
-            ip: context.ip ?? s.ip,
-            route: context.route ?? s.route,
-            method: context.method ?? s.method
-        });
+        return this.createContextualLogger(mergeCallContextFields(this.staticMetadata, context, REQUEST_CONTEXT_FIELDS));
     }
     withJobContext(context) {
-        const s = this.staticMetadata;
-        return this.createContextualLogger({
-            ...s,
-            jobId: context.jobId ?? s.jobId,
-            queueId: context.queueId ?? s.queueId,
-            queueName: context.queueName ?? s.queueName,
-            toolId: context.toolId ?? s.toolId,
-            parentJobId: context.parentJobId ?? s.parentJobId,
-            attempt: context.attempt ?? s.attempt,
-            maxAttempts: context.maxAttempts ?? s.maxAttempts
-        });
+        return this.createContextualLogger(mergeCallContextFields(this.staticMetadata, context, JOB_CONTEXT_FIELDS));
     }
     performanceTracker(params) {
         let startTime = 0;
-        const tracker = this.withContext({ operation: params.operation, ...params.metadata });
+        // The params are read once, without throwing: a non-string operation is labelled `unlabeled` and reported once.
+        const { operation, merged } = readTrackerParams(this.staticMetadata, params);
+        const tracker = this.createContextualLogger(merged);
+        // `end`/`fail` contexts are read at the boundary too: an unreadable one becomes the entry's loggingError, reported once.
         return {
             start() {
                 startTime = Date.now();
-                tracker.debug(`operation.${params.operation}.start`);
+                tracker.debug(`operation.${operation}.start`);
             },
             end(successContext) {
                 const duration = Date.now() - startTime;
-                tracker.info(`operation.${params.operation}.success`, { duration, ...successContext });
+                tracker.emit('info', `operation.${operation}.success`, () => mergeCallContexts({ duration }, successContext));
             },
-            fail(error, errorContext) {
+            fail: PerformanceFailureSchema.implement((error, errorContext) => {
                 const duration = Date.now() - startTime;
-                tracker.error(`operation.${params.operation}.failure`, {
-                    duration,
-                    error,
-                    ...errorContext
-                });
-            }
+                tracker.emit('error', `operation.${operation}.failure`, () => mergeFailureContexts({ duration }, error, errorContext));
+            })
         };
     }
 }