mikser-io 9.61.1 → 9.63.0

package/CLAUDE.md

@@ -233,7 +233,14 @@ brevity.
   - `{ name, options, postprocess, output?, setup?, teardown? }` →
     postprocessor descriptor; stored in `runtime.postprocessors`.
   Strings produce a v9 migration error pointing at the new shape.
-- `manager.js` — file watching (chokidar) and cron scheduling.
+- `manager.js` — file watching (chokidar) and cron scheduling. `watch()`
+  turns file events into SYNC events — it is how a source folder becomes
+  entities, so pointing it at the output folder feeds output back in as
+  input. `watchFolder(folder, handler, options)` is the primitive without
+  that meaning, for a plugin that only needs to know bytes changed; it
+  carries the shared junk filter and `followSymlinks: true`, which is
+  load-bearing because the files plugin serves by symlinking into the
+  output folder.
 - `source.js` — `useSource` codifies the folder-of-files pattern.
 - `tools.js` — tool registry. `registerTool(name, {description,
   inputSchema}, handler)` / `toolNames()` / `toolSchema()` / `invokeTool()`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io",
-  "version": "9.61.1",
+  "version": "9.63.0",
   "description": "A mixer for content: entities in, configurable render pipelines, outputs of any kind. Static sites are the canonical recipe, not the definition — the same engine renders PDFs, emails and whatever a renderer plugin produces. Files are the source of truth, every lifecycle phase is observable, and the build graph is queryable by an agent.",
   "main": "index.js",
   "exports": {

package/src/manager.js

@@ -90,6 +90,33 @@ export async function deletedHook(name, context) {
 // `ignored` and a function is the one form that has stayed stable.
 const ignoreJunk = (filePath) => /[/\\]\./.test(filePath) || junkFilter()(filePath)
 
+// Watch a folder, with mikser's own settings and none of its lifecycle.
+//
+// `watch()` below turns file events into SYNC events — it is how a source
+// folder becomes entities, and pointing it at anything else feeds output back
+// in as input. A plugin that only wants to know when bytes changed needs the
+// watching without the meaning, and was otherwise reaching for chokidar
+// directly: a second copy of a dependency the engine already has, and a second
+// junk filter that would drift from this one.
+//
+// followSymlinks matters more than it looks. The files plugin serves a file by
+// symlinking it from the source folder into the output folder, so a watcher on
+// the output folder that did not follow links would see the link created once
+// and never hear about the file again — every stylesheet edit silently
+// invisible to anything watching what is served.
+export function watchFolder(folder, handler, options = {}) {
+    return chokidar
+        .watch(folder, {
+            interval: 1000,
+            binaryInterval: 3000,
+            ignored: ignoreJunk,
+            ignoreInitial: true,
+            followSymlinks: true,
+            ...options,
+        })
+        .on('all', (event, fullPath) => handler(event, fullPath))
+}
+
 export function watch(name, folder, options = { interval: 1000, binaryInterval: 3000, ignored: ignoreJunk, ignoreInitial: true }) {
     if (runtime.options.watch !== true) return
 

package/src/server.js

@@ -22,11 +22,25 @@
 
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { networkInterfaces } from 'node:os'
 
 import runtime from './runtime.js'
 import { useLogger } from './engine.js'
 import { onInitialized, onLoad, onLoaded } from './lifecycle.js'
 
+// Every non-loopback IPv4 address this machine answers on.
+//
+// IPv4 only, deliberately. The non-internal IPv6 addresses on a typical
+// machine are link-local (fe80::), which need a zone index to be usable and
+// are not what anyone is going to type into a phone — listing them would make
+// the useful lines harder to find, which is the opposite of the point.
+export function localAddresses() {
+    return Object.values(networkInterfaces())
+        .flat()
+        .filter(iface => iface && iface.family === 'IPv4' && !iface.internal)
+        .map(iface => iface.address)
+}
+
 // Extend the engine's commander with server-related flags. Called by
 // engine.js's onInitialize callback AFTER engine's own options chain
 // and BEFORE the .parse() call — preserves the order of options in
@@ -214,6 +228,28 @@ export function setupServer() {
                     // back to the bind URL when no public origin is set.
                     const externalUrl = runtime.options.url ?? `http://localhost:${runtime.options.port}`
                     logger.info('Server listening: %s', externalUrl)
+
+                    // The addresses that are NOT localhost.
+                    //
+                    // listen(port) binds every interface, so the server is
+                    // already reachable from a phone or a second machine —
+                    // and the one address printed above is the single one
+                    // that will not work from either. Anyone testing a
+                    // layout on a real device has to go and find their own
+                    // IP, every time, on a machine that already knows it.
+                    //
+                    // Only when no public URL is configured. Behind a proxy
+                    // or a tunnel the LAN address is not how the site is
+                    // reached, and offering it would be an invitation to
+                    // debug the wrong origin.
+                    if (!runtime.options.url) {
+                        const lan = localAddresses()
+                        if (lan.length) {
+                            logger.info('Also on: %s', lan
+                                .map(address => `http://${address}:${runtime.options.port}`)
+                                .join('  '))
+                        }
+                    }
                     resolve()
                 })