@fougere/log 0.9.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fougere contributors
+
+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/dist/FileHandler.d.ts

@@ -0,0 +1,25 @@
+import type { Fact, LogLine } from '@fougere/core';
+/** Where the lines land, and the only thing this destination is configured with. */
+export declare class LogFile {
+    readonly path: string;
+    constructor(path: string);
+}
+/**
+ * One JSON object per line, appended to a file — the shape a collector tails.
+ *
+ * A destination sends a line ELSEWHERE: the console is core's, written whoever else took
+ * the line, so a handler that printed would say everything twice.
+ *
+ * It announces NOTHING. A destination that logs is a ring, and the emission refuses it by
+ * name where `onLog`'s try/catch used to swallow it.
+ *
+ * In `src/` and not under a `fronds/` directory: that name is what a SCAN reads, and this
+ * frond is stated, because a published package is read by no scanner.
+ */
+export default class FileHandler {
+    private file;
+    constructor(file: LogFile);
+    /** Append one line. */
+    record(line: Fact<LogLine>): Promise<void>;
+}
+//# sourceMappingURL=FileHandler.d.ts.map

package/dist/FileHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileHandler.d.ts","sourceRoot":"","sources":["../src/FileHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAEnD,oFAAoF;AACpF,qBAAa,OAAO;IACN,QAAQ,CAAC,IAAI,EAAE,MAAM;IAAjC,YAAqB,IAAI,EAAE,MAAM,EAAI;CACtC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,OAAO,WAAW;IAClB,OAAO,CAAC,IAAI;IAAxB,YAAoB,IAAI,EAAE,OAAO,EAAI;IAErC,uBAAuB;IACjB,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;CACF"}

package/dist/FileHandler.js

@@ -0,0 +1,31 @@
+import { appendFile } from 'node:fs/promises';
+/** Where the lines land, and the only thing this destination is configured with. */
+export class LogFile {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+}
+/**
+ * One JSON object per line, appended to a file — the shape a collector tails.
+ *
+ * A destination sends a line ELSEWHERE: the console is core's, written whoever else took
+ * the line, so a handler that printed would say everything twice.
+ *
+ * It announces NOTHING. A destination that logs is a ring, and the emission refuses it by
+ * name where `onLog`'s try/catch used to swallow it.
+ *
+ * In `src/` and not under a `fronds/` directory: that name is what a SCAN reads, and this
+ * frond is stated, because a published package is read by no scanner.
+ */
+export default class FileHandler {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    /** Append one line. */
+    async record(line) {
+        await appendFile(this.file.path, `${JSON.stringify(line)}\n`, 'utf8');
+    }
+}
+//# sourceMappingURL=FileHandler.js.map

package/dist/FileHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileHandler.js","sourceRoot":"","sources":["../src/FileHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,oFAAoF;AACpF,MAAM,OAAO,OAAO;IACG,IAAI;IAAzB,YAAqB,IAAY;oBAAZ,IAAI;IAAW,CAAC;CACtC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,OAAO,WAAW;IACV,IAAI;IAAxB,YAAoB,IAAa;oBAAb,IAAI;IAAY,CAAC;IAErC,uBAAuB;IACvB,KAAK,CAAC,MAAM,CAAC,IAAmB;QAC9B,MAAM,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACxE,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { default as FileHandler, LogFile } from './FileHandler.js';
+/**
+ * Lines to a file, one JSON object each. Leave it out and they only reach the console —
+ * which is the whole difference from a logger you have to turn off.
+ *
+ * The path is closed over by a subclass rather than registered: a frond states classes, and
+ * a value it should be constructed with has no key to answer under.
+ */
+export declare const logFrond: (path: string) => import("@fougere/core").FrondDescriptor;
+//# 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,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,SAAU,MAAM,4CAoBpC,CAAC"}

package/dist/index.js

@@ -0,0 +1,41 @@
+/**
+ * Where a log line GOES. The line itself is core's — the boot announces one before any
+ * frond exists, so naming it there would cost core an optional package's vocabulary, and
+ * the console is core's too: it writes every line whoever else took it.
+ *
+ * So what this package holds is a destination that sends a line SOMEWHERE ELSE. Stated and
+ * not scanned: `frond()` is what a published package hands over, so a consumer needs no
+ * TypeScript loader and no scan of its `node_modules`. The contract is written here for the
+ * same reason — nobody reads this handler's source at boot.
+ */
+import { frond, LogLine } from '@fougere/core';
+import FileHandler, { LogFile } from './FileHandler.js';
+export { default as FileHandler, LogFile } from './FileHandler.js';
+/**
+ * Lines to a file, one JSON object each. Leave it out and they only reach the console —
+ * which is the whole difference from a logger you have to turn off.
+ *
+ * The path is closed over by a subclass rather than registered: a frond states classes, and
+ * a value it should be constructed with has no key to answer under.
+ */
+export const logFrond = (path) => {
+    class Lines extends FileHandler {
+        constructor() {
+            super(new LogFile(path));
+        }
+    }
+    return frond('log', {
+        entities: [LogLine],
+        handlers: [{
+                ctor: Lines,
+                deps: [],
+                operations: {
+                    record: {
+                        input: LogLine,
+                        binding: [{ name: 'line', optional: false, source: { kind: 'fact', factName: 'logLine' } }],
+                    },
+                },
+            }],
+    });
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,WAAW,EAAE,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,EAAE;IACvC,MAAM,KAAM,SAAQ,WAAW;QAC7B;YACE,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3B,CAAC;KACF;IAED,OAAO,KAAK,CAAC,KAAK,EAAE;QAClB,QAAQ,EAAE,CAAC,OAAO,CAAC;QACnB,QAAQ,EAAE,CAAC;gBACT,IAAI,EAAE,KAAK;gBACX,IAAI,EAAE,EAAE;gBACR,UAAU,EAAE;oBACV,MAAM,EAAE;wBACN,KAAK,EAAE,OAAO;wBACd,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,CAAC;qBAC5F;iBACF;aACF,CAAC;KACH,CAAC,CAAC;AACL,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@fougere/log",
+  "version": "0.9.0-alpha.0",
+  "description": "Logging for Fougere: a line is an announced fact, and a destination is a handler that accepts it. Ships the console one.",
+  "keywords": [
+    "fougere",
+    "typescript",
+    "logging",
+    "observability"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chok/fougere.git",
+    "directory": "packages/log"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "peerDependencies": {
+    "@fougere/core": "^0.9.0-alpha.0",
+    "@fougere/schema": "^0.9.0-alpha.0"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.0",
+    "jiti": "^2.6.1",
+    "@fougere/compiler": "0.9.0-alpha.0",
+    "@fougere/container": "0.9.0-alpha.0",
+    "@fougere/testing": "0.9.0-alpha.0",
+    "@fougere/core": "0.9.0-alpha.0",
+    "@fougere/schema": "0.9.0-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json"
+  }
+}

package/src/FileHandler.ts

@@ -0,0 +1,28 @@
+import { appendFile } from 'node:fs/promises';
+import type { Fact, LogLine } from '@fougere/core';
+
+/** Where the lines land, and the only thing this destination is configured with. */
+export class LogFile {
+  constructor(readonly path: string) {}
+}
+
+/**
+ * One JSON object per line, appended to a file — the shape a collector tails.
+ *
+ * A destination sends a line ELSEWHERE: the console is core's, written whoever else took
+ * the line, so a handler that printed would say everything twice.
+ *
+ * It announces NOTHING. A destination that logs is a ring, and the emission refuses it by
+ * name where `onLog`'s try/catch used to swallow it.
+ *
+ * In `src/` and not under a `fronds/` directory: that name is what a SCAN reads, and this
+ * frond is stated, because a published package is read by no scanner.
+ */
+export default class FileHandler {
+  constructor(private file: LogFile) {}
+
+  /** Append one line. */
+  async record(line: Fact<LogLine>): Promise<void> {
+    await appendFile(this.file.path, `${JSON.stringify(line)}\n`, 'utf8');
+  }
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Where a log line GOES. The line itself is core's — the boot announces one before any
+ * frond exists, so naming it there would cost core an optional package's vocabulary, and
+ * the console is core's too: it writes every line whoever else took it.
+ *
+ * So what this package holds is a destination that sends a line SOMEWHERE ELSE. Stated and
+ * not scanned: `frond()` is what a published package hands over, so a consumer needs no
+ * TypeScript loader and no scan of its `node_modules`. The contract is written here for the
+ * same reason — nobody reads this handler's source at boot.
+ */
+import { frond, LogLine } from '@fougere/core';
+import FileHandler, { LogFile } from './FileHandler.js';
+
+export { default as FileHandler, LogFile } from './FileHandler.js';
+
+/**
+ * Lines to a file, one JSON object each. Leave it out and they only reach the console —
+ * which is the whole difference from a logger you have to turn off.
+ *
+ * The path is closed over by a subclass rather than registered: a frond states classes, and
+ * a value it should be constructed with has no key to answer under.
+ */
+export const logFrond = (path: string) => {
+  class Lines extends FileHandler {
+    constructor() {
+      super(new LogFile(path));
+    }
+  }
+
+  return frond('log', {
+    entities: [LogLine],
+    handlers: [{
+      ctor: Lines,
+      deps: [],
+      operations: {
+        record: {
+          input: LogLine,
+          binding: [{ name: 'line', optional: false, source: { kind: 'fact', factName: 'logLine' } }],
+        },
+      },
+    }],
+  });
+};