@vibesdotdev/logging 0.0.1 → 1.0.0-rc.4

package/dist/outputs/file/file.outputs.descriptor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * File Output Descriptor
+ *
+ * Writes logs to local files with rotation support.
+ * Consumer hardware only.
+ */
+import type { OutputDescriptor } from '@vibesdotdev/logging/schemas/output';
+export declare const fileOutputDescriptor: OutputDescriptor;
+export default fileOutputDescriptor;
+//# sourceMappingURL=file.outputs.descriptor.d.ts.map

package/dist/outputs/file/file.outputs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.outputs.descriptor.d.ts","sourceRoot":"","sources":["../../../src/outputs/file/file.outputs.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAE5E,eAAO,MAAM,oBAAoB,EAAE,gBAuBlC,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/outputs/file/file.outputs.descriptor.js

@@ -0,0 +1,32 @@
+/**
+ * File Output Descriptor
+ *
+ * Writes logs to local files with rotation support.
+ * Consumer hardware only.
+ */
+export const fileOutputDescriptor = {
+    kind: 'logging/output',
+    id: 'file',
+    name: 'File Output',
+    description: 'Writes logs to local files with rotation',
+    tags: ['local', 'persistent'],
+    hardware: ['consumer'],
+    storage: 'file',
+    // This lazy backend can create absolute streams on an unbound host.
+    optionalContext: ['runtime/workspace-path'],
+    format: 'jsonl',
+    path: 'logs/app.log',
+    rotation: {
+        maxSize: '10MB',
+        maxAge: '7d',
+        maxFiles: 5
+    },
+    buffering: {
+        enabled: true,
+        size: 8192,
+        flushInterval: 1000,
+        maxBufferEntries: 10000
+    }
+};
+export default fileOutputDescriptor;
+//# sourceMappingURL=file.outputs.descriptor.js.map

package/dist/outputs/file/file.outputs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.outputs.descriptor.js","sourceRoot":"","sources":["../../../src/outputs/file/file.outputs.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,CAAC,MAAM,oBAAoB,GAAqB;IACrD,IAAI,EAAE,gBAAgB;IACtB,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,aAAa;IACnB,WAAW,EAAE,0CAA0C;IACvD,IAAI,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC;IAC7B,QAAQ,EAAE,CAAC,UAAU,CAAC;IACtB,OAAO,EAAE,MAAM;IACf,oEAAoE;IACpE,eAAe,EAAE,CAAC,wBAAwB,CAAC;IAC3C,MAAM,EAAE,OAAO;IACf,IAAI,EAAE,cAAc;IACpB,QAAQ,EAAE;QACT,OAAO,EAAE,MAAM;QACf,MAAM,EAAE,IAAI;QACZ,QAAQ,EAAE,CAAC;KACX;IACD,SAAS,EAAE;QACV,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,IAAI;QACV,aAAa,EAAE,IAAI;QACnB,gBAAgB,EAAE,KAAK;KACvB;CACD,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/outputs/remote/remote.descriptor.d.ts

@@ -2,7 +2,7 @@
  * Remote Output Descriptor
  *
  * Sends logs to a remote HTTP endpoint.
- * Cloud hardware target.
+ * Portable HTTP backend for consumer and cloud hosts.
  */
 import type { OutputDescriptor } from '../../schemas/output.ts';
 export declare const remoteOutputDescriptor: OutputDescriptor;

package/dist/outputs/remote/remote.descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.descriptor.d.ts","sourceRoot":"","sources":["../../../src/outputs/remote/remote.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,eAAO,MAAM,sBAAsB,EAAE,gBAepC,CAAC;AAEF,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"remote.descriptor.d.ts","sourceRoot":"","sources":["../../../src/outputs/remote/remote.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,eAAO,MAAM,sBAAsB,EAAE,gBAcpC,CAAC;AAEF,eAAe,sBAAsB,CAAC"}

package/dist/outputs/remote/remote.descriptor.js

@@ -2,7 +2,7 @@
  * Remote Output Descriptor
  *
  * Sends logs to a remote HTTP endpoint.
- * Cloud hardware target.
+ * Portable HTTP backend for consumer and cloud hosts.
  */
 export const remoteOutputDescriptor = {
     kind: 'logging/output',
@@ -10,7 +10,6 @@ export const remoteOutputDescriptor = {
     name: 'Remote Output',
     description: 'Sends logs to a remote HTTP endpoint',
     tags: ['cloud', 'centralized'],
-    hardware: ['cloud'],
     storage: 'remote',
     format: 'jsonl',
     buffering: {

package/dist/outputs/remote/remote.descriptor.js.map

@@ -1 +1 @@
-{"version":3,"file":"remote.descriptor.js","sourceRoot":"","sources":["../../../src/outputs/remote/remote.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,CAAC,MAAM,sBAAsB,GAAqB;IACvD,IAAI,EAAE,gBAAgB;IACtB,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,sCAAsC;IACnD,IAAI,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC;IAC9B,QAAQ,EAAE,CAAC,OAAO,CAAC;IACnB,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE,OAAO;IACf,SAAS,EAAE;QACV,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,KAAK;QACX,aAAa,EAAE,IAAI;QACnB,gBAAgB,EAAE,IAAI;KACtB;CACD,CAAC;AAEF,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"remote.descriptor.js","sourceRoot":"","sources":["../../../src/outputs/remote/remote.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,CAAC,MAAM,sBAAsB,GAAqB;IACvD,IAAI,EAAE,gBAAgB;IACtB,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,sCAAsC;IACnD,IAAI,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC;IAC9B,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE,OAAO;IACf,SAAS,EAAE;QACV,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,KAAK;QACX,aAAa,EAAE,IAAI;QACnB,gBAAgB,EAAE,IAAI;KACtB;CACD,CAAC;AAEF,eAAe,sBAAsB,CAAC"}

package/dist/outputs/remote/remote.factory.d.ts

@@ -0,0 +1,9 @@
+import { DefaultOutputImplementation } from '../../kinds/output.impl.ts';
+import type { OutputBackendFactory, OutputContext } from '../../kinds/output.types.ts';
+import { type OutputDescriptor } from '../../schemas/output.ts';
+import RemoteOutput from './remote.impl.ts';
+/** The Runtime selects the factory; each stream retains that provider's context. A context of the same Root (its view or reload generation) is accepted; another Root's is refused. */
+export default class RemoteOutputFactory extends DefaultOutputImplementation implements OutputBackendFactory {
+    create(descriptor: OutputDescriptor, namedContext: OutputContext): RemoteOutput;
+}
+//# sourceMappingURL=remote.factory.d.ts.map

package/dist/outputs/remote/remote.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.factory.d.ts","sourceRoot":"","sources":["../../../src/outputs/remote/remote.factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAA0B,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACxF,OAAO,YAAY,MAAM,kBAAkB,CAAC;AAG5C,uLAAuL;AACvL,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,2BAA4B,YAAW,oBAAoB;IAC3G,MAAM,CAAC,UAAU,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,GAAG,YAAY;CAM/E"}

package/dist/outputs/remote/remote.factory.js

@@ -0,0 +1,16 @@
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { DefaultOutputImplementation } from "../../kinds/output.impl.js";
+import { OutputDescriptorSchema } from "../../schemas/output.js";
+import RemoteOutput from "./remote.impl.js";
+import { loggingRootOf } from "../../core/root-identity.js";
+/** The Runtime selects the factory; each stream retains that provider's context. A context of the same Root (its view or reload generation) is accepted; another Root's is refused. */
+export default class RemoteOutputFactory extends DefaultOutputImplementation {
+    create(descriptor, namedContext) {
+        if (loggingRootOf(namedContext.runtime) !== loggingRootOf(this.context.runtime))
+            throw new CapabilityError('A remote stream context belongs to another Root.', 'CONFLICT', {
+                reason: 'output-context-runtime-mismatch', retryable: false
+            });
+        return new RemoteOutput(OutputDescriptorSchema.parse(descriptor), { ...this.context, ...namedContext, runtime: this.context.runtime });
+    }
+}
+//# sourceMappingURL=remote.factory.js.map

package/dist/outputs/remote/remote.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.factory.js","sourceRoot":"","sources":["../../../src/outputs/remote/remote.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAEzE,OAAO,EAAE,sBAAsB,EAAyB,MAAM,yBAAyB,CAAC;AACxF,OAAO,YAAY,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D,uLAAuL;AACvL,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,2BAA2B;IAC3E,MAAM,CAAC,UAA4B,EAAE,YAA2B;QAC/D,IAAI,aAAa,CAAC,YAAY,CAAC,OAAO,CAAC,KAAK,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;YAAE,MAAM,IAAI,eAAe,CAAC,kDAAkD,EAAE,UAAU,EAAE;gBAC1K,MAAM,EAAE,iCAAiC,EAAE,SAAS,EAAE,KAAK;aAC3D,CAAC,CAAC;QACH,OAAO,IAAI,YAAY,CAAC,sBAAsB,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,GAAG,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACxI,CAAC;CACD"}

package/dist/outputs/remote/remote.impl.d.ts

@@ -4,8 +4,10 @@
  * Batched HTTP delivery to a logging endpoint.
  */
 import type { OutputImplementation, OutputContext, OutputReadOptions, OutputTailOptions, TailHandle, OutputStats } from '../../kinds/output.ts';
-import type { OutputDescriptor } from '../../schemas/output.ts';
+import { type OutputDescriptor } from '../../schemas/output.ts';
 import type { RuntimeLogEntry } from '../../schemas/entry.ts';
+/** The default deadline for one remote delivery request. */
+export declare const REMOTE_DELIVERY_TIMEOUT_MS = 10000;
 /** Metrics for buffer operations */
 interface BufferMetrics {
     /** Total entries added to buffer */
@@ -24,19 +26,43 @@ export default class RemoteOutput implements OutputImplementation {
     readonly id: string;
     readonly descriptor: OutputDescriptor;
     private readonly formatter;
-    private readonly endpoint;
+    private endpoint;
     private readonly buffering;
     private readonly maxBufferEntries;
     private buffer;
-    private flushTimer;
-    private isFlushing;
+    private acceptedSequence;
+    /** The one-shot flush pending for the current buffer (lifecycle-owned, RC07). */
+    private flushDisposer;
+    /** The output's own runtime: its lifecycle owns the flush timer. */
+    private readonly runtime;
+    private flushPromise;
+    private readonly pendingDiagnostics;
+    private readonly pendingDeliveries;
+    private closePromise;
+    private closing;
     private metrics;
     constructor(descriptor: OutputDescriptor, context: OutputContext);
+    /**
+     * One lifecycle-owned flush per non-empty buffer, `flushInterval` after the
+     * buffer's first entry. Once the runtime's disposal has begun no flush can be
+     * scheduled; `close()` flushes what remains.
+     */
+    private scheduleFlush;
     /** Get current buffer metrics */
     getMetrics(): BufferMetrics;
     /** Get current buffer size */
     getBufferSize(): number;
     private addToBuffer;
+    /**
+     * Serialize first: an entry is measured as JSON before it is accepted, so an
+     * entry JSON cannot carry (a bigint, a cycle, a throwing `toJSON` handed to a
+     * direct `write`) refuses that caller only, typed and value-free, and never
+     * enters the buffer, where it would fail every later write, flush and close.
+     */
+    private accept;
+    /** The buffer's size as one JSON array of its entries, from the sizes measured at acceptance. */
+    private bufferedSize;
+    private assertWritable;
     write(entry: RuntimeLogEntry): Promise<void>;
     writeBatch(entries: RuntimeLogEntry[]): Promise<void>;
     flush(): Promise<void>;
@@ -44,6 +70,16 @@ export default class RemoteOutput implements OutputImplementation {
     tail(_callback: (line: string) => void, _options?: OutputTailOptions): TailHandle;
     stats(): Promise<OutputStats>;
     close(): Promise<void>;
+    private resolveEndpoint;
+    private deliver;
+    /**
+     * One POST under the runtime lifecycle's deadline (no ad hoc timer). Past
+     * `deliveryTimeoutMs` the request is aborted and fails. When the runtime's
+     * disposal begins mid-request, the accepted delivery is joined, not
+     * abandoned: it keeps running under a finalization wait capped by the
+     * remaining budget, and is aborted when that runs out.
+     */
+    private request;
     private send;
 }
 export {};

package/dist/outputs/remote/remote.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.impl.d.ts","sourceRoot":"","sources":["../../../src/outputs/remote/remote.impl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACX,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,yBAAyB,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAQ9D,oCAAoC;AACpC,UAAU,aAAa;IACtB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,YAAW,oBAAoB;IAChE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAgE;gBAEnE,UAAU,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa;IA8BhE,iCAAiC;IACjC,UAAU,IAAI,aAAa;IAI3B,8BAA8B;IAC9B,aAAa,IAAI,MAAM;IAIvB,OAAO,CAAC,WAAW;IAwBb,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAc5C,UAAU,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAarD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAYtB,IAAI,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAK3D,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,UAAU;IAK3E,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC;IAI7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAWd,IAAI;CAsClB"}
+{"version":3,"file":"remote.impl.d.ts","sourceRoot":"","sources":["../../../src/outputs/remote/remote.impl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACX,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAA0B,KAAK,gBAAgB,EAAwB,MAAM,yBAAyB,CAAC;AAC9G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAa9D,4DAA4D;AAC5D,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAWjD,oCAAoC;AACpC,UAAU,aAAa;IACtB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,YAAW,oBAAoB;IAChE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,gBAAgB,CAAK;IAC7B,iFAAiF;IACjF,OAAO,CAAC,aAAa,CAAyB;IAC9C,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqC;IACxE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwC;IAC1E,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAgE;gBAEnE,UAAU,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa;IAiBhE;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAcrB,iCAAiC;IACjC,UAAU,IAAI,aAAa;IAI3B,8BAA8B;IAC9B,aAAa,IAAI,MAAM;IAIvB,OAAO,CAAC,WAAW;IAOnB;;;;;OAKG;IACH,OAAO,CAAC,MAAM;IAcd,iGAAiG;IACjG,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,cAAc;IAShB,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB5C,UAAU,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBhB,IAAI,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAK3D,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,UAAU;IAK3E,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC;IAInC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAuBR,eAAe;IAY7B,OAAO,CAAC,OAAO;IAQf;;;;;;OAMG;YACW,OAAO;YA6BP,IAAI;CA8BlB"}

package/dist/outputs/remote/remote.impl.js

@@ -3,10 +3,20 @@
  *
  * Batched HTTP delivery to a logging endpoint.
  */
-import { getDefaultLogger } from "../../contexts/logger.js";
-const logger = getDefaultLogger();
-/** Default remote endpoint */
-const DEFAULT_ENDPOINT = 'http://localhost:3000/api/logs';
+import { OutputDescriptorSchema } from "../../schemas/output.js";
+import * as z from 'zod/v4';
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { loadLoggingConfig } from "../../config/load-config.js";
+import { createFallbackLogger } from "../../contexts/fallback-logger.js";
+import { LoggedErrorSchema, ReadableErrorNameSchema } from "../../core/redact.js";
+import { RedactedEndpointSchema, createEndpointFailureSchema, createEndpointTextSchema } from "../../core/endpoint.js";
+import { attempt, settle } from "../../core/outcome.js";
+import JsonlFormatter from "../../formatters/jsonl/jsonl.impl.js";
+import jsonlFormatterDescriptor from "../../formatters/jsonl/jsonl.descriptor.js";
+import { trackLoggingResource, untrackLoggingResource } from "../../core/output-resources.js";
+/** The default deadline for one remote delivery request. */
+export const REMOTE_DELIVERY_TIMEOUT_MS = 10_000;
+const WaitAbortedSchema = z.object({ code: z.literal('CANCELLED'), reason: z.literal('wait-aborted') });
 /**
  * Remote output - sends logs via HTTP.
  */
@@ -18,34 +28,52 @@ export default class RemoteOutput {
     buffering;
     maxBufferEntries;
     buffer = [];
-    flushTimer = null;
-    isFlushing = false;
+    acceptedSequence = 0;
+    /** The one-shot flush pending for the current buffer (lifecycle-owned, RC07). */
+    flushDisposer = null;
+    /** The output's own runtime: its lifecycle owns the flush timer. */
+    runtime;
+    flushPromise = null;
+    pendingDiagnostics = new Set();
+    pendingDeliveries = new Set();
+    closePromise = null;
+    closing = false;
     metrics = { added: 0, sent: 0, dropped: 0, retried: 0 };
     constructor(descriptor, context) {
-        this.id = descriptor.id;
-        this.descriptor = descriptor;
-        // Use formatter from context or create default
-        this.formatter = context.formatter ?? {
-            format: (e) => JSON.stringify(e),
-            parse: (s) => JSON.parse(s),
-            formatBatch: (entries) => entries.map((e) => JSON.stringify(e)).join('\n')
-        };
-        // Configuration
-        this.endpoint = descriptor.endpoint ?? DEFAULT_ENDPOINT;
-        this.buffering = descriptor.buffering ?? {
+        this.descriptor = OutputDescriptorSchema.parse(descriptor);
+        this.id = this.descriptor.id;
+        this.runtime = context.runtime;
+        this.formatter = context.formatter ?? new JsonlFormatter(jsonlFormatterDescriptor, { runtime: context.runtime });
+        this.endpoint = this.descriptor.endpoint;
+        this.buffering = this.descriptor.buffering ?? {
             enabled: true,
             size: 16384,
             flushInterval: 5000,
             maxBufferEntries: 10000
         };
         this.maxBufferEntries = this.buffering.maxBufferEntries ?? 10000;
-        // Start flush timer if buffering enabled
-        if (this.buffering.enabled && this.buffering.flushInterval) {
-            this.flushTimer = setInterval(() => {
-                this.flush().catch((err) => logger.error('Remote output flush error', { error: err }));
-            }, this.buffering.flushInterval);
-            this.flushTimer.unref?.();
-        }
+        trackLoggingResource(this.runtime, this);
+    }
+    /**
+     * One lifecycle-owned flush per non-empty buffer, `flushInterval` after the
+     * buffer's first entry. Once the runtime's disposal has begun no flush can be
+     * scheduled; `close()` flushes what remains.
+     */
+    scheduleFlush() {
+        if (this.closing || this.flushDisposer || !this.buffering.flushInterval || this.buffer.length === 0)
+            return;
+        if (this.runtime.lifecycle.signal.aborted)
+            return;
+        this.flushDisposer = this.runtime.lifecycle.timeout(() => {
+            this.flushDisposer = null;
+            // The scheduled flush has no caller: its failure is reported, and a failed report is close's to throw.
+            const diagnostics = settle(settle(this.flush()).then(async (flushed) => {
+                if (flushed.failed)
+                    (await createFallbackLogger('logging:remote-output', this.runtime)).error('Remote output flush error', { error: LoggedErrorSchema.parse(flushed.cause) });
+            }));
+            this.pendingDiagnostics.add(diagnostics);
+            void diagnostics.then(() => this.pendingDiagnostics.delete(diagnostics));
+        }, this.buffering.flushInterval);
     }
     /** Get current buffer metrics */
     getMetrics() {
@@ -56,65 +84,97 @@ export default class RemoteOutput {
         return this.buffer.length;
     }
     addToBuffer(entries) {
-        const spaceAvailable = this.maxBufferEntries - this.buffer.length;
-        if (entries.length <= spaceAvailable) {
-            // All entries fit
-            this.buffer.push(...entries);
-            this.metrics.added += entries.length;
-        }
-        else if (spaceAvailable > 0) {
-            // Partial fit - add what we can, drop the oldest to make room for rest
-            const toAdd = entries.slice(-spaceAvailable); // Keep newest entries
-            const toDrop = entries.slice(0, entries.length - spaceAvailable);
-            this.buffer.push(...toAdd);
-            this.metrics.added += toAdd.length;
-            this.metrics.dropped += toDrop.length;
-        }
-        else {
-            // No space - drop oldest entries to make room for newest
-            const dropCount = Math.min(entries.length, this.maxBufferEntries);
-            this.buffer.splice(0, dropCount); // Remove oldest
-            this.metrics.dropped += dropCount;
-            this.buffer.push(...entries);
-            this.metrics.added += entries.length;
+        const dropped = Math.max(0, this.buffer.length + entries.length - this.maxBufferEntries);
+        this.metrics.added += entries.length;
+        this.metrics.dropped += dropped;
+        this.buffer = this.buffer.concat(entries).sort((left, right) => left.order - right.order).slice(-this.maxBufferEntries);
+    }
+    /**
+     * Serialize first: an entry is measured as JSON before it is accepted, so an
+     * entry JSON cannot carry (a bigint, a cycle, a throwing `toJSON` handed to a
+     * direct `write`) refuses that caller only, typed and value-free, and never
+     * enters the buffer, where it would fail every later write, flush and close.
+     */
+    accept(entries) {
+        const measured = entries.map((entry, index) => {
+            const size = attempt(() => JSON.stringify(entry).length);
+            if (size.failed) {
+                throw new CapabilityError('The remote output cannot serialize this entry as JSON, so it was not accepted.', 'INVALID_INPUT', {
+                    reason: 'remote-entry-unserializable', retryable: false,
+                    details: { id: this.id, index, errorName: ReadableErrorNameSchema.parse(size.cause) }
+                });
+            }
+            return { entry, size: size.value };
+        });
+        return measured.map(({ entry, size }) => ({ entry, size, order: this.acceptedSequence++ }));
+    }
+    /** The buffer's size as one JSON array of its entries, from the sizes measured at acceptance. */
+    bufferedSize() {
+        return this.buffer.reduce((total, value) => total + value.size + 1, 1);
+    }
+    assertWritable() {
+        if (this.closing || this.runtime.lifecycle.signal.aborted) {
+            throw new CapabilityError('The remote output no longer accepts writes.', 'UNAVAILABLE', {
+                reason: this.closing ? 'output-closed' : 'output-runtime-disposed',
+                details: { id: this.id }, cause: this.runtime.lifecycle.signal.reason
+            });
         }
     }
     async write(entry) {
+        this.assertWritable();
+        const accepted = this.accept([entry]);
         if (this.buffering.enabled) {
-            this.addToBuffer([entry]);
+            this.addToBuffer(accepted);
             // Flush if buffer is large enough
-            const estimatedSize = JSON.stringify(this.buffer).length;
-            if (estimatedSize >= this.buffering.size) {
+            if (this.bufferedSize() >= this.buffering.size) {
                 await this.flush();
             }
+            else {
+                this.scheduleFlush();
+            }
         }
         else {
-            await this.send([entry]);
+            await this.deliver(accepted);
         }
     }
     async writeBatch(entries) {
+        this.assertWritable();
+        const accepted = this.accept(entries);
         if (this.buffering.enabled) {
-            this.addToBuffer(entries);
-            const estimatedSize = JSON.stringify(this.buffer).length;
-            if (estimatedSize >= this.buffering.size) {
+            this.addToBuffer(accepted);
+            if (this.bufferedSize() >= this.buffering.size) {
                 await this.flush();
             }
+            else {
+                this.scheduleFlush();
+            }
         }
         else {
-            await this.send(entries);
+            await this.deliver(accepted);
         }
     }
-    async flush() {
-        if (this.buffer.length === 0 || this.isFlushing)
-            return;
-        this.isFlushing = true;
-        try {
-            const entries = this.buffer.splice(0);
-            await this.send(entries);
-        }
-        finally {
-            this.isFlushing = false;
+    flush() {
+        if (this.flushDisposer) {
+            this.flushDisposer();
+            this.flushDisposer = null;
         }
+        if (this.flushPromise)
+            return this.flushPromise;
+        if (this.buffer.length === 0)
+            return Promise.resolve();
+        const entries = this.buffer.splice(0);
+        this.flushPromise = this.deliver(entries).catch(error => {
+            // Preflight failures remain the caller's original refusal, with accepted entries retained.
+            this.addToBuffer(entries);
+            this.metrics.retried += entries.length;
+            throw error;
+        }).then(sent => {
+            if (sent && this.buffering.enabled)
+                this.scheduleFlush();
+        }).finally(() => {
+            this.flushPromise = null;
+        });
+        return this.flushPromise;
     }
     async read(_options) {
         // Remote outputs do not support reading
@@ -127,52 +187,117 @@ export default class RemoteOutput {
     async stats() {
         return { size: 0, exists: true };
     }
-    async close() {
-        // Clear flush timer
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-            this.flushTimer = null;
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closing = true;
+        if (this.flushDisposer) {
+            this.flushDisposer();
+            this.flushDisposer = null;
+        }
+        this.closePromise = (async () => {
+            const accepted = await Promise.all([...this.pendingDeliveries, ...this.pendingDiagnostics]);
+            const failures = accepted.flatMap(outcome => outcome.failed ? [outcome.cause] : []);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, 'Accepted remote deliveries failed while closing.');
+            if (this.flushPromise)
+                await this.flushPromise;
+            await this.flush();
+            untrackLoggingResource(this.runtime, this);
+            // A final flush the collector refused re-buffers its entries: closing with them is a loss, never a success.
+            if (this.buffer.length > 0)
+                throw new CapabilityError('The remote output closed with entries the collector did not accept.', 'UNAVAILABLE', {
+                    reason: 'remote-final-flush-undelivered', retryable: false, details: { id: this.id, retained: this.buffer.length }
+                });
+        })();
+        return this.closePromise;
+    }
+    async resolveEndpoint() {
+        if (this.endpoint)
+            return this.endpoint;
+        const settings = await loadLoggingConfig(this.runtime);
+        if (!settings.remoteEndpoint) {
+            throw new CapabilityError('A remote output needs an endpoint: set `endpoint` on its descriptor or `remoteEndpoint` in the logging settings.', 'INVALID_INPUT', {
+                reason: 'remote-endpoint-missing', retryable: false, details: { id: this.id }
+            });
+        }
+        this.endpoint = settings.remoteEndpoint;
+        return this.endpoint;
+    }
+    deliver(entries) {
+        const pending = this.send(entries);
+        const delivered = settle(pending);
+        this.pendingDeliveries.add(delivered);
+        void delivered.then(() => this.pendingDeliveries.delete(delivered));
+        return pending;
+    }
+    /**
+     * One POST under the runtime lifecycle's deadline (no ad hoc timer). Past
+     * `deliveryTimeoutMs` the request is aborted and fails. When the runtime's
+     * disposal begins mid-request, the accepted delivery is joined, not
+     * abandoned: it keeps running under a finalization wait capped by the
+     * remaining budget, and is aborted when that runs out.
+     */
+    async request(endpoint, body) {
+        const controller = new AbortController();
+        const timeoutMs = this.descriptor.deliveryTimeoutMs ?? REMOTE_DELIVERY_TIMEOUT_MS;
+        const reason = 'logging-remote-delivery';
+        // The request's own outcome is observed once here, so an aborted request
+        // never rejects unobserved after its wait has already settled.
+        const response = settle(fetch(endpoint, {
+            method: 'POST', headers: { 'Content-Type': 'application/x-ndjson' }, body, signal: controller.signal
+        }));
+        const answered = (outcome) => {
+            if (outcome.failed)
+                throw outcome.cause;
+            return outcome.value;
+        };
+        const bounded = () => this.runtime.lifecycle.wait(() => response, { timeoutMs, reason });
+        const first = await settle(bounded());
+        if (!first.failed)
+            return answered(first.value);
+        const joinable = WaitAbortedSchema.safeParse(first.cause).success && this.runtime.lifecycle.signal.aborted;
+        if (!joinable) {
+            controller.abort(first.cause);
+            throw first.cause;
         }
-        // Flush remaining buffer
-        await this.flush();
+        const joined = await settle(bounded());
+        if (joined.failed) {
+            controller.abort(joined.cause);
+            throw joined.cause;
+        }
+        return answered(joined.value);
     }
     async send(entries) {
         if (entries.length === 0)
-            return;
+            return true;
+        const endpoint = await this.resolveEndpoint();
         const body = this.formatter.formatBatch
-            ? this.formatter.formatBatch(entries)
-            : entries.map((e) => this.formatter.format(e)).join('\n');
-        try {
-            const response = await fetch(this.endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/x-ndjson'
-                },
-                body
+            ? this.formatter.formatBatch(entries.map(value => value.entry))
+            : entries.map(value => this.formatter.format(value.entry)).join('\n');
+        const requested = await settle(this.request(endpoint, body));
+        if (requested.failed) {
+            this.addToBuffer(entries);
+            this.metrics.retried += entries.length;
+            (await createFallbackLogger('logging:remote-output', this.runtime)).error('Network error sending logs to remote endpoint', {
+                error: createEndpointFailureSchema(endpoint).parse(requested.cause), endpoint: RedactedEndpointSchema.parse(endpoint)
             });
-            if (!response.ok) {
-                logger.error('Failed to send logs to remote endpoint', {
-                    status: response.status,
-                    statusText: response.statusText,
-                    endpoint: this.endpoint
-                });
-                // Re-add failed entries to buffer for retry
-                this.addToBuffer(entries);
-                this.metrics.retried += entries.length;
-            }
-            else {
-                this.metrics.sent += entries.length;
-            }
+            return false;
         }
-        catch (error) {
-            logger.error('Network error sending logs to remote endpoint', {
-                error: error instanceof Error ? error.message : String(error),
-                endpoint: this.endpoint
-            });
-            // Re-add failed entries to buffer for retry
+        const response = requested.value;
+        if (!response.ok) {
+            // The reason phrase is the collector's text and may echo the request line, query credential included: it is scrubbed.
             this.addToBuffer(entries);
             this.metrics.retried += entries.length;
+            (await createFallbackLogger('logging:remote-output', this.runtime)).error('Failed to send logs to remote endpoint', {
+                status: response.status, statusText: createEndpointTextSchema(endpoint).parse(response.statusText), endpoint: RedactedEndpointSchema.parse(endpoint)
+            });
+            return false;
         }
+        this.metrics.sent += entries.length;
+        return true;
     }
 }
 //# sourceMappingURL=remote.impl.js.map