functionalscript 0.46.1 → 0.47.0

package/fjs/media/revision/module.f.d.mts

@@ -91,8 +91,14 @@ export declare const lockField: LockFieldSchema;
  * rtti schema for a `revision` BLOB. See the README for the full semantics of
  * each field; `dialect` is the type discriminant, matched here as an exact
  * literal so structural validation alone rejects any other dialect's blob.
+ *
+ * `open`, and deliberately so: a bare struct is closed, so an older reader
+ * would reject a blob a newer writer had added a field to, and this dialect's
+ * own versioning rule — additive extension keeps the tag, see `./README.md` —
+ * is stated in terms of that older reader accepting it. Do not drop the
+ * wrapper.
  */
-export declare const revisionSchema: {
+export declare const revisionSchema: import("../../types/rtti/types.ts").Rest<{
     readonly dialect: "vnd.fjs.revision";
     readonly subject: import("../../types/rtti/types.ts")._Type0<"string">;
     readonly parents: import("../../types/rtti/types.ts").Type1<"array", import("../../types/rtti/types.ts")._Type0<"string">>;
@@ -100,7 +106,7 @@ export declare const revisionSchema: {
     readonly generation: import("../../types/rtti/types.ts")._Type0<"number">;
     readonly archived: import("../../types/rtti/types.ts").Or<readonly [true, undefined]>;
     readonly lock: import("../../types/rtti/types.ts").Or<readonly [LockFieldSchema, undefined]>;
-};
+}, import("../../types/rtti/types.ts").Unknown>;
 /** Serializes a revision canonically, recursively sorting every object's property names.
  * @type {(revision: Revision) => string}
  */

package/fjs/media/revision/module.f.mjs

@@ -21,7 +21,7 @@
  * @import { LockField, LockFieldSchema, LockMap, LockSchema, Revision, RevisionError } from './types.ts'
  */
 
-import { array, number, option, string } from '../../types/rtti/module.f.mjs'
+import { array, number, open, option, string } from '../../types/rtti/module.f.mjs'
 import { parse as rttiParse } from '../../types/rtti/parse/module.f.mjs'
 import { parse as parseJson } from '../json/module.f.mjs'
 import { cBase32ToVec } from '../../basen/cbase32/module.f.mjs'
@@ -113,8 +113,14 @@ export const lockField = () => ['or', hash, lock]
  * rtti schema for a `revision` BLOB. See the README for the full semantics of
  * each field; `dialect` is the type discriminant, matched here as an exact
  * literal so structural validation alone rejects any other dialect's blob.
+ *
+ * `open`, and deliberately so: a bare struct is closed, so an older reader
+ * would reject a blob a newer writer had added a field to, and this dialect's
+ * own versioning rule — additive extension keeps the tag, see `./README.md` —
+ * is stated in terms of that older reader accepting it. Do not drop the
+ * wrapper.
  */
-export const revisionSchema = /** @type {const} */ ({
+export const revisionSchema = open(/** @type {const} */ ({
     dialect,
     subject: string,
     parents: array(hash),
@@ -122,7 +128,7 @@ export const revisionSchema = /** @type {const} */ ({
     generation: number,
     archived: option(true),
     lock: option(lockField),
-})
+}))
 
 /** Serializes a revision canonically, recursively sorting every object's property names.
  * @type {(revision: Revision) => string}

package/fjs/media/revision/proof.f.mjs

@@ -228,7 +228,7 @@ export const proof = {
             assertEq(t, 'error')
         },
 
-        // rtti structs are open: extra fields don't break validation — the
+        // `revisionSchema` says `open`: extra fields don't break validation — the
         // additive forward-compatibility path the versioning rule relies on.
         extraFieldsAccepted: () => {
             const [t] = validate(revisionOf({ future: 'field' }))

package/fjs/media/revision/types.d.ts

@@ -5,7 +5,7 @@
  *
  * `LockMap` is written by hand rather than derived, so that the recursion
  * reads directly, and is then pinned against the module's rtti schema with
- * `Assert<Equal<LockMap, Ts<typeof lock>>>` — the same arrangement the JSON
+ * `Assert<Check<LockMap, typeof lock>>` — the same arrangement the JSON
  * data model uses in [`../json/types.ts`](../json/types.ts). `LockSchema` is
  * the schema side of the same recursion: `lock` cannot infer its own type
  * (a `const` may not reference itself in its own initializer), so it carries

package/fjs/media/type/module.f.d.mts

@@ -31,6 +31,12 @@
  * sits between the `RIFF` and `WEBP` markers, so its pattern carries four
  * wildcard bytes rather than being one contiguous run.
  *
+ * Beside the two byte sniffers, `detectPath` answers the same question from the
+ * other end — the `Content-Type` a *file name* implies, read off its extension.
+ * A sniffer cannot serve that question at all: `text/html`, `text/css` and
+ * `text/javascript` are byte-identical UTF-8 text, and only the name tells them
+ * apart.
+ *
  * See `./types.ts` for the type-level API.
  *
  * @module
@@ -130,3 +136,17 @@ export declare const detectVec: (bytes: Vec) => DetectMeta;
  * @returns {Effect<O, DetectMeta, IoChannel>}
  */
 export declare const detectStream: <O extends Operation>(stream: List<O, Vec, IoChannel>) => Effect<O, DetectMeta, IoChannel>;
+/**
+ * The `Content-Type` a file name implies, from its extension alone — the bytes
+ * are never read. Text types carry `; charset=utf-8`, so the result is a
+ * complete header value rather than a bare media type; an absent or unknown
+ * extension is `application/octet-stream`.
+ *
+ * This is the counterpart of {@link detect}, not a replacement for it: sniffing
+ * answers what unlabelled bytes are, and this answers what a named file claims
+ * to be. A server needs the second — the three text formats a browser treats
+ * differently are byte-identical to a sniffer.
+ *
+ * @type {(path: string) => string}
+ */
+export declare const detectPath: (path: string) => string;

package/fjs/media/type/module.f.mjs

@@ -31,6 +31,12 @@
  * sits between the `RIFF` and `WEBP` markers, so its pattern carries four
  * wildcard bytes rather than being one contiguous run.
  *
+ * Beside the two byte sniffers, `detectPath` answers the same question from the
+ * other end — the `Content-Type` a *file name* implies, read off its extension.
+ * A sniffer cannot serve that question at all: `text/html`, `text/css` and
+ * `text/javascript` are byte-identical UTF-8 text, and only the name tells them
+ * apart.
+ *
  * See `./types.ts` for the type-level API.
  *
  * @module
@@ -49,6 +55,7 @@ import { iterable } from '../../types/list/module.f.mjs'
 import { pureOk, step as ioStep } from '../../effects/module.f.mjs'
 import { isValidCodePoint, isTextCodePoint } from '../../text/code_point/module.f.mjs'
 import { utf8ByteToCodePointOp } from '../../text/utf8/module.f.mjs'
+import { at } from '../../types/object/module.f.mjs'
 
 // ── Magic-byte signatures ─────────────────────────────────────────────────────────
 //
@@ -269,3 +276,70 @@ export const detectStream = stream => {
             })
     return loop(detectInit)(stream)
 }
+
+// ── Extension table ───────────────────────────────────────────────────────────────
+//
+// The same question asked from the other end: not "what do these bytes look like"
+// but "what does this file name claim to be". A server answering `Content-Type`
+// needs the second, because the first cannot tell `text/html` from `text/css` from
+// `text/javascript` — every one of them is plain UTF-8 text, and only the extension
+// distinguishes them.
+
+/**
+ * Media type by lower-case file-name extension, without the `charset` parameter
+ * {@link detectPath} adds. Deliberately small: the types the pages under
+ * `fjs/website` are built from, plus the image formats {@link detect} already
+ * recognizes.
+ */
+const byExtension = /** @type {const} */ ({
+    html: 'text/html',
+    css: 'text/css',
+    js: 'text/javascript',
+    mjs: 'text/javascript',
+    json: 'application/json',
+    svg: 'image/svg+xml',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    wasm: 'application/wasm',
+    txt: 'text/plain',
+})
+
+/** The answer for a name whose extension is absent or unknown.
+ *
+ * @type {string}
+ */
+const octetStream = 'application/octet-stream'
+
+/**
+ * The lower-case extension of the last segment of `path`, or `''` when it has
+ * none. A leading dot is a name, not an extension: `.gitignore` has none.
+ *
+ * @type {(path: string) => string}
+ */
+const extension = path => {
+    const name = path.slice(path.lastIndexOf('/') + 1)
+    const dot = name.lastIndexOf('.')
+    return dot > 0 ? name.slice(dot + 1).toLowerCase() : ''
+}
+
+/**
+ * The `Content-Type` a file name implies, from its extension alone — the bytes
+ * are never read. Text types carry `; charset=utf-8`, so the result is a
+ * complete header value rather than a bare media type; an absent or unknown
+ * extension is `application/octet-stream`.
+ *
+ * This is the counterpart of {@link detect}, not a replacement for it: sniffing
+ * answers what unlabelled bytes are, and this answers what a named file claims
+ * to be. A server needs the second — the three text formats a browser treats
+ * differently are byte-identical to a sniffer.
+ *
+ * @type {(path: string) => string}
+ */
+export const detectPath = path => {
+    const mime = at(extension(path))(byExtension)
+    if (mime === null) { return octetStream }
+    return mime.startsWith('text/') ? `${mime}; charset=utf-8` : mime
+}

package/fjs/media/type/proof.f.d.mts

@@ -54,4 +54,9 @@ export declare const proof: {
         octetStream: () => void;
         nul: () => void;
     };
+    detectPath: {
+        text: () => void;
+        binary: () => void;
+        fallback: () => void;
+    };
 };

package/fjs/media/type/proof.f.mjs

@@ -12,7 +12,7 @@ import { nonEmpty, empty as emptyList } from '../../effects/list/module.f.mjs'
 import { pureError } from '../../effects/module.f.mjs'
 import { error, ok } from '../../types/result/module.f.mjs'
 import { ioError } from '../../effects/node/module.f.mjs'
-import { detect, detectStream, detectVec } from './module.f.mjs'
+import { detect, detectPath, detectStream, detectVec } from './module.f.mjs'
 
 // Builds a big-endian `Vec` from a list of byte values — mirrors how the CAS
 // store would hold the leading bytes of a stored blob.
@@ -342,4 +342,27 @@ export const proof = {
             assertEq(m.length, 3n)
         },
     },
+    detectPath: {
+        // A text type carries the charset, so the answer is a complete header
+        // value rather than a bare media type.
+        text: () => {
+            assertEq(detectPath('index.html'), 'text/html; charset=utf-8')
+            assertEq(detectPath('a/b/main.css'), 'text/css; charset=utf-8')
+            assertEq(detectPath('module.f.mjs'), 'text/javascript; charset=utf-8')
+        },
+        // A binary type does not: `charset` says nothing about bytes.
+        binary: () => {
+            assertEq(detectPath('logo.png'), 'image/png')
+            assertEq(detectPath('photo.JPG'), 'image/jpeg')
+            assertEq(detectPath('vm.wasm'), 'application/wasm')
+        },
+        // The names that carry no extension, plus an extension nothing claims.
+        fallback: () => {
+            assertEq(detectPath('README'), 'application/octet-stream')
+            assertEq(detectPath('.gitignore'), 'application/octet-stream')
+            assertEq(detectPath('archive.tar.zst'), 'application/octet-stream')
+            // A dot in a parent directory is not this file's extension.
+            assertEq(detectPath('v1.2/README'), 'application/octet-stream')
+        },
+    },
 }

package/fjs/module.f.mjs

@@ -14,6 +14,7 @@ import { main as ciMain } from './ci/module.f.mjs'
 import { errorExit, errorMessage, exitStep, import_ } from './effects/node/module.f.mjs'
 import { dispatch } from './cli/module.f.mjs'
 import { casMcpServer } from './mcp/module.f.mjs'
+import { main as webMain } from './web/module.f.mjs'
 import { resultStep } from './effects/module.f.mjs'
 
 /** @type {Commands<NodeOp>} */
@@ -53,6 +54,11 @@ const commands = [
         description: 'Generate the GitHub Actions CI workflow',
         handler: ciMain,
     },
+    {
+        names: ['web', 'w'],
+        description: 'Serve a directory over HTTP',
+        handler: webMain,
+    },
     {
         names: ['run', 'r'],
         description: 'Run a FunctionalScript module as a NodeProgram',

package/fjs/path/module.f.d.mts

@@ -1,6 +1,12 @@
 /**
  * Path parsing and normalization helpers for portable module paths.
  *
+ * A path is a {@link root} followed by segments. The root is what makes the
+ * path absolute — `/`, `//` for a UNC path, or `C:/` for a Windows drive —
+ * and it is not a segment: it survives normalization, and `..` cannot escape
+ * it. Everything after it folds by the usual rules, so `a//b` is `a/b` and
+ * `a/../b` is `b`.
+ *
  * @module
  *
  * @import { Fold, Reduce, Unary } from '../types/function/operator/types.ts'
@@ -14,17 +20,62 @@ import type { Reduce, Unary } from '../types/function/operator/types.ts';
  */
 export declare const toPosix: (path: string) => string;
 /**
- * Splits a path into normalized segments.
+ * The root of a path, carrying its trailing separator: `'/'` for a POSIX
+ * absolute path, `'//'` for a UNC one, `'C:/'` for a Windows drive, and `''`
+ * for a relative path.
+ *
+ * `..` cannot escape whatever this answers, so it is also the definition of
+ * how far up a path can go. On Windows that is not quite the whole story: the
+ * `server/share` of a UNC path is part of its root there and is an ordinary
+ * segment here, so `..` can still climb past a share — see
+ * {@link split} for why the root stops at `//`.
+ *
+ * A drive root is the one that folding can *create*. `/` and `//` are prefixes
+ * of the text, so no amount of `.`/`..` collapsing produces one; `C:/` is a
+ * segment's content, so a relative path whose first segment happens to be a
+ * drive letter becomes drive-rooted once folded — `root('./C:/a')` is `''`
+ * while `root(normalize('./C:/a'))` is `'C:/'`. On Windows that is the reading
+ * that is wanted; on a POSIX host with a directory actually named `C:` it is
+ * not, and this module has no way to tell the two apart after folding.
+ *
+ * @type {(path: string) => string}
+ */
+export declare const root: (path: string) => string;
+/**
+ * Splits a path into normalized segments, *without* its root — `parse('/a/b')`
+ * and `parse('a/b')` are both `['a', 'b']`. Use {@link root} to ask whether the
+ * path was absolute, or {@link normalize} for a string that keeps it.
  *
  * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
  * (`".."`) segments collapse the previous segment when possible, and Windows
- * separators are converted to POSIX separators.
+ * separators are converted to POSIX separators. A `".."` that would escape a
+ * root is dropped rather than kept.
  *
  * @type {(path: string) => readonly string[]}
  */
 export declare const parse: (path: string) => readonly string[];
 /**
- * Normalizes a path string by parsing and rejoining it with POSIX separators.
+ * Whether a `..` in `path` would climb above its root — what a caller asks when
+ * it has to *refuse* a traversal rather than clamp one.
+ *
+ * {@link parse} cannot answer it: `parse` folds with the root in place, and the
+ * escaping `..` is precisely what that removes. Here the root comes off first
+ * and the remainder folds as a relative path, where a `..` with nothing left to
+ * cancel survives to be counted.
+ *
+ * Taking the root off is not the same as dropping a leading `/`. The remainder
+ * of `///../x` is `//../x` and the remainder of `/C:/../../x` is
+ * `C:/../../x` — both read as rooted again, and folding them a second time
+ * would clamp the very `..` being looked for. The fold is told there is no
+ * root instead of being handed a string that looks like it has none.
+ *
+ * @type {(path: string) => boolean}
+ */
+export declare const escapes: (path: string) => boolean;
+/**
+ * Normalizes a path string by parsing and rejoining it with POSIX separators,
+ * keeping the root: `normalize('/a/./b')` is `'/a/b'` and `normalize('/')` is
+ * `'/'`.
  *
  * @type {Unary<string, string>}
  */
@@ -32,6 +83,12 @@ export declare const normalize: Unary<string, string>;
 /**
  * Concatenates two path fragments and returns a normalized path.
  *
+ * An absolute `b` names a path on its own, so it replaces `a` rather than being
+ * appended to it. Otherwise the root comes from `a` and the segments from the
+ * two joined — taking the root from `a` rather than from the joined string is
+ * what stops the separator between them from being read as a root of its own,
+ * so `concat('')('../x')` is `'../x'` and not `'x'`.
+ *
  * @type {Reduce<string>}
  */
 export declare const concat: Reduce<string>;

package/fjs/path/module.f.mjs

@@ -1,6 +1,12 @@
 /**
  * Path parsing and normalization helpers for portable module paths.
  *
+ * A path is a {@link root} followed by segments. The root is what makes the
+ * path absolute — `/`, `//` for a UNC path, or `C:/` for a Windows drive —
+ * and it is not a segment: it survives normalization, and `..` cannot escape
+ * it. Everything after it folds by the usual rules, so `a//b` is `a/b` and
+ * `a/../b` is `b`.
+ *
  * @module
  *
  * @import { Fold, Reduce, Unary } from '../types/function/operator/types.ts'
@@ -10,13 +16,19 @@
 import { fold, last, take, length, concat as listConcat, toArray } from '../types/list/module.f.mjs'
 import { join as listJoin, concat as stringConcat } from '../types/string/module.f.mjs'
 
-/** @type {Fold<string, List<string>>} */
-const foldNormalizeOp = input => state => {
+/**
+ * `rooted` is the only thing the fold needs to know about the root: whether a
+ * leading `..` has anywhere to go. `/a/../..` is `/`, because there is no
+ * parent of the root to name, while `a/../..` stays `..`.
+ *
+ * @type {(rooted: boolean) => Fold<string, List<string>>}
+ */
+const foldNormalizeOp = rooted => input => state => {
     switch(input) {
         case '': case '.': { return state }
         case '..': {
             switch(last(undefined)(state)) {
-                case undefined:
+                case undefined: { return rooted ? state : listConcat(state)([input]) }
                 case '..': { return listConcat(state)([input]) }
             }
             return take(length(state) - 1)(state)
@@ -32,38 +44,150 @@ const foldNormalizeOp = input => state => {
  */
 export const toPosix = path => path.replaceAll('\\', '/')
 
+/** @type {(c: string) => boolean} */
+const isDriveLetter = c => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
+
+/**
+ * A Windows drive root, and only in its absolute spelling: `C:/` roots the
+ * path, while a bare `C:` and the drive-relative `C:foo` — which names the
+ * current directory *on* drive C — do not, and stay ordinary segments.
+ *
+ * @type {(p: string) => boolean}
+ */
+const isDriveRoot = p => p.length >= 3 && p[1] === ':' && p[2] === '/' && isDriveLetter(p[0])
+
+/**
+ * A bare drive, which {@link isDriveRoot} deliberately excludes — and which
+ * {@link concat} must therefore not turn into one. The separator `concat`
+ * inserts between its two arguments is what would do it: `C:` and `dir` joined
+ * with a `/` is the drive root `C:/dir` rather than the drive-relative `C:dir`,
+ * a different place on the disk. Joined without one, the answer stays the kind
+ * of path it started as.
+ *
+ * This keeps `concat` from changing a path's kind. It does not make the
+ * drive-relative form *resolve* like Windows: `C:dir` is one ordinary segment
+ * here, so `concat('C:dir')('../..')` is `'..'` where Windows says `C:..`.
+ * Modelling that needs a third kind of path, which this module does not have.
+ *
+ * @type {(p: string) => boolean}
+ */
+const isBareDrive = p => p.length === 2 && p[1] === ':' && isDriveLetter(p[0])
+
+/**
+ * Splits an already-POSIX path into its root and everything after it, so that
+ * `root + rest` is the path again. The root carries its own trailing separator
+ * — `'/'`, `'//'`, `'C:/'`, or `''` — which is what lets {@link rejoin} put a
+ * path back together without a separator of its own.
+ *
+ * A root is a fixed-width prefix here, never a parsed one. `//` marks a UNC
+ * path but stops there rather than swallowing `server/share`: those are two
+ * arbitrary segments, and a path like `//a/../../etc/passwd` would fold `../`
+ * *into* the root, which is precisely what a root must not do. Three or more
+ * leading slashes are an ordinary root followed by empty segments, which is
+ * what POSIX requires.
+ *
+ * @type {(p: string) => readonly [root: string, rest: string]}
+ */
+const split = p =>
+    p.startsWith('//') && !p.startsWith('///') ? ['//', p.slice(2)]
+    : p.startsWith('/') ? ['/', p.slice(1)]
+    : isDriveRoot(p) ? [p.slice(0, 3), p.slice(3)]
+    : ['', p]
+
+/** @type {(rooted: boolean) => (rest: string) => readonly string[]} */
+const posixSegments = rooted => rest => toArray(fold(foldNormalizeOp(rooted))([])(rest.split('/')))
+
+/** @type {(s: readonly [string, string]) => string} */
+const rejoin = ([r, rest]) => stringConcat([r, listJoin('/')(posixSegments(r !== '')(rest))])
+
+/**
+ * The root of a path, carrying its trailing separator: `'/'` for a POSIX
+ * absolute path, `'//'` for a UNC one, `'C:/'` for a Windows drive, and `''`
+ * for a relative path.
+ *
+ * `..` cannot escape whatever this answers, so it is also the definition of
+ * how far up a path can go. On Windows that is not quite the whole story: the
+ * `server/share` of a UNC path is part of its root there and is an ordinary
+ * segment here, so `..` can still climb past a share — see
+ * {@link split} for why the root stops at `//`.
+ *
+ * A drive root is the one that folding can *create*. `/` and `//` are prefixes
+ * of the text, so no amount of `.`/`..` collapsing produces one; `C:/` is a
+ * segment's content, so a relative path whose first segment happens to be a
+ * drive letter becomes drive-rooted once folded — `root('./C:/a')` is `''`
+ * while `root(normalize('./C:/a'))` is `'C:/'`. On Windows that is the reading
+ * that is wanted; on a POSIX host with a directory actually named `C:` it is
+ * not, and this module has no way to tell the two apart after folding.
+ *
+ * @type {(path: string) => string}
+ */
+export const root = path => split(toPosix(path))[0]
+
 /**
- * Splits a path into normalized segments.
+ * Splits a path into normalized segments, *without* its root — `parse('/a/b')`
+ * and `parse('a/b')` are both `['a', 'b']`. Use {@link root} to ask whether the
+ * path was absolute, or {@link normalize} for a string that keeps it.
  *
  * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
  * (`".."`) segments collapse the previous segment when possible, and Windows
- * separators are converted to POSIX separators.
+ * separators are converted to POSIX separators. A `".."` that would escape a
+ * root is dropped rather than kept.
  *
  * @type {(path: string) => readonly string[]}
  */
 export const parse = path => {
-    const split = toPosix(path).split('/')
-    return toArray(fold(foldNormalizeOp)([])(split))
+    const [r, rest] = split(toPosix(path))
+    return posixSegments(r !== '')(rest)
 }
 
 /**
- * Normalizes a path string by parsing and rejoining it with POSIX separators.
+ * Whether a `..` in `path` would climb above its root — what a caller asks when
+ * it has to *refuse* a traversal rather than clamp one.
+ *
+ * {@link parse} cannot answer it: `parse` folds with the root in place, and the
+ * escaping `..` is precisely what that removes. Here the root comes off first
+ * and the remainder folds as a relative path, where a `..` with nothing left to
+ * cancel survives to be counted.
+ *
+ * Taking the root off is not the same as dropping a leading `/`. The remainder
+ * of `///../x` is `//../x` and the remainder of `/C:/../../x` is
+ * `C:/../../x` — both read as rooted again, and folding them a second time
+ * would clamp the very `..` being looked for. The fold is told there is no
+ * root instead of being handed a string that looks like it has none.
+ *
+ * @type {(path: string) => boolean}
+ */
+export const escapes = path => posixSegments(false)(split(toPosix(path))[1]).includes('..')
+
+/**
+ * Normalizes a path string by parsing and rejoining it with POSIX separators,
+ * keeping the root: `normalize('/a/./b')` is `'/a/b'` and `normalize('/')` is
+ * `'/'`.
  *
  * @type {Unary<string, string>}
  */
-export const normalize = path => {
-    const foldResult = parse(path)
-    return listJoin('/')(foldResult)
-}
+export const normalize = path => rejoin(split(toPosix(path)))
 
 /**
  * Concatenates two path fragments and returns a normalized path.
  *
+ * An absolute `b` names a path on its own, so it replaces `a` rather than being
+ * appended to it. Otherwise the root comes from `a` and the segments from the
+ * two joined — taking the root from `a` rather than from the joined string is
+ * what stops the separator between them from being read as a root of its own,
+ * so `concat('')('../x')` is `'../x'` and not `'x'`.
+ *
  * @type {Reduce<string>}
  */
 export const concat = a => b => {
-    const s = stringConcat([a, '/', b])
-    return normalize(s)
+    const [rb, restb] = split(toPosix(b))
+    if (rb !== '') { return rejoin([rb, restb]) }
+    // `a` is normalized before its root is read, because what `a` *is* decides
+    // the join and only the folded form answers that: `./C:` and `x/../C:` are
+    // both the bare drive `C:`, and reading them unfolded would insert the
+    // separator that makes a drive root out of one.
+    const [ra, resta] = split(normalize(a))
+    return rejoin([ra, stringConcat([resta, isBareDrive(resta) ? '' : '/', restb])])
 }
 
 /**

package/fjs/path/proof.f.d.mts

@@ -1,5 +1,8 @@
 export declare const proof: {
     normalizeTest: (() => void)[];
+    escapesTest: (() => void)[];
+    rootTest: (() => void)[];
+    parseTest: (() => void)[];
     concatTest: (() => void)[];
     joinTest: (() => void)[];
     relativizeTest: (() => void)[];