doctrina-cli 0.21.0 → 0.22.0

package/src/lib/fs-ops.js

@@ -42,17 +42,68 @@ export function withEol(text, eol) {
   return eol === "\n" ? lf : lf.replace(/\n/g, "\r\n");
 }
 
+// ...and so is the line ending (seventh audit, change 0250).
+//
+// A Windows checkout with `core.autocrlf` stores every artifact with CRLF,
+// and the grammar was read with patterns written for LF. `.*$` does not
+// cross a `\r`, so a header stamp matched nothing and reported success; a
+// placeholder bullet `-\r` read as an empty requirement, and a fresh spec
+// carried five EARS warnings an LF checkout never saw; a line diff showed
+// the whole file as changed. Each was fixed where it was found, one caller
+// at a time (`eolOf`/`withEol`), and the next caller forgot.
+//
+// So the rule is the door's: text is READ with LF, whatever the file holds,
+// and WRITTEN BACK with the ending the file already has. No parser
+// downstream has to know which checkout it is running in, and a rewrite
+// never mixes endings or turns a file's every line into a diff.
 export function read(p) {
   const text = readFileSync(p, "utf8");
-  return text.charCodeAt(0) === 0xFEFF ? text.slice(1) : text;
+  const body = text.charCodeAt(0) === 0xFEFF ? text.slice(1) : text;
+  return body.includes("\r\n") ? body.replace(/\r\n/g, "\n") : body;
 }
 
-export function write(p, content, { force = false } = {}) {
-  if (existsSync(p) && !force) {
+/** Does the file at `p` end its lines with CRLF today? False when absent or unreadable. */
+function storedAsCrlf(p) {
+  try {
+    return readFileSync(p, "utf8").includes("\r\n");
+  } catch {
+    return false;
+  }
+}
+
+export function write(p, content, { force = false, atomic = false } = {}) {
+  const there = existsSync(p);
+  if (there && !force) {
     throw new Error(`refusing to overwrite existing file: ${p} (pass --force to allow)`);
   }
   mkdirSync(path.dirname(p), { recursive: true });
-  writeFileSync(p, content);
+  // A rewrite keeps the ending the file has; a new file is written as given.
+  const text = there && typeof content === "string" && storedAsCrlf(p)
+    ? content.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n")
+    : content;
+  if (!atomic) {
+    writeFileSync(p, text);
+    return;
+  }
+  // Whole or not at all: written beside the target and moved over it, so a
+  // command reading the file at that instant never sees half of it. Where the
+  // move is refused (a reader holding the file open on Windows) the plain
+  // write still lands.
+  const tmp = `${p}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, text);
+    renameSync(tmp, p);
+  } catch {
+    writeFileSync(p, text);
+    try {
+      unlinkSync(tmp);
+    } catch { /* never created, or already moved */ }
+  }
+}
+
+/** Append `line` to the text file at `p`, with the ending the file already uses. */
+export function appendLine(p, line) {
+  writeFileSync(p, `${line}${storedAsCrlf(p) ? "\r\n" : "\n"}`, { flag: "a" });
 }
 
 export function exists(p) {
@@ -133,17 +184,34 @@ export function pruneEmptyDirs(dir, stopAt) {
   return removed;
 }
 
-// Recursive file walk. Returns absolute paths of every regular file.
-export function walk(root) {
+// Recursive file walk. Returns absolute paths of every regular file, sorted.
+//
+// The directory listing already says what each entry is, so it is asked
+// once (change 0249): the walk used to `stat` every entry twice — is it a
+// directory? is it a file? — which was a third of `validate`'s time on this
+// repository. A symbolic link is still followed with a `stat`, as before.
+// `depth` bounds how far down it goes: 1 is the files directly in `root`.
+/**
+ * @param {string} root
+ * @param {{ depth?: number }} [opts]
+ * @returns {string[]}
+ */
+export function walk(root, { depth = Infinity } = {}) {
+  /** @type {string[]} */
   const out = [];
   if (!exists(root)) return out;
-  const stack = [root];
+  /** @type {[string, number][]} */
+  const stack = [[root, 1]];
   while (stack.length) {
-    const dir = stack.pop();
-    for (const entry of readdirSync(dir)) {
-      const full = path.join(dir, entry);
-      if (isDir(full)) stack.push(full);
-      else if (isFile(full)) out.push(full);
+    const [dir, level] = /** @type {[string, number]} */ (stack.pop());
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      const link = entry.isSymbolicLink();
+      if (link ? isDir(full) : entry.isDirectory()) {
+        if (level < depth) stack.push([full, level + 1]);
+      } else if (link ? isFile(full) : entry.isFile()) {
+        out.push(full);
+      }
     }
   }
   return out.sort();

package/src/lib/gates.js

@@ -67,7 +67,7 @@ export const GATES = {
     blockers(projectRoot, changeDir) {
       const out = [];
       // Same counter as every other surface (change 0067).
-      const countUnchecked = (text, section = null) =>
+      const countUnchecked = (text, section = /** @type {string | null} */ (null)) =>
         checklistProgress(text, { section }).total - checklistProgress(text, { section }).done;
 
       const tasksPath = path.join(changeDir, "tasks.md");
@@ -224,6 +224,12 @@ export const SEQUENCES = {
     // the CLI's source, which is how a pt-BR project sat red under `clarify`
     // with no clue why (change 0047). Advisory: a default is not a fault.
     { id: "config", label: "config", level: "advisory", argv: null, rerun: "edit .doctrina/config.json" },
+    // Which `doctrina` the terminal runs, and how the repository merges
+    // (changes 0242, 0243). Readouts of the machine and the clone, not of the
+    // artifacts: the hooks call `doctrina` by name, so a second install ahead
+    // on the PATH is the one they run.
+    { id: "cli", label: "cli", level: "advisory", argv: null, rerun: "doctrina --version" },
+    { id: "merges", label: "merges", level: "advisory", argv: null, rerun: "doctrina hooks install" },
     // Also a readout, and also advisory. It appears only when the operator
     // has switched the usage log on: an instrument that is off has nothing
     // to say, and a row saying so every run would train the reader to skip

package/src/lib/git.js

@@ -69,6 +69,24 @@ export function git(cwd, args, { env } = {}) {
   return { state: GIT_STATE.FAILED, stdout: "", lines: [], stderr, code: r.status };
 }
 
+/**
+ * Where git keeps `name` for the repository `cwd` is in — `hooks`,
+ * `info/exclude` — as an absolute path, or null outside a repository. Asked
+ * of git, never built from `.git/`: in a worktree and in a submodule `.git`
+ * is a FILE, and `core.hooksPath` moves the hooks anywhere (change 0250).
+ */
+export function gitPathOf(cwd, name) {
+  const r = git(cwd, ["rev-parse", "--git-path", name]);
+  if (r.state !== GIT_STATE.OK || r.stdout.trim() === "") return null;
+  return path.resolve(cwd, r.stdout.trim());
+}
+
+/** `cwd` relative to the top of its repository, with forward slashes ("" at the top), or null outside one. */
+export function repoPrefix(cwd) {
+  const r = git(cwd, ["rev-parse", "--show-prefix"]);
+  return r.state === GIT_STATE.OK ? r.stdout.trim().replace(/\/+$/, "") : null;
+}
+
 // Is this a git repository at all?
 export function isRepo(cwd) {
   return git(cwd, ["rev-parse", "--is-inside-work-tree"]).state === GIT_STATE.OK;

package/src/lib/index-json.js

@@ -30,6 +30,12 @@ export function load(projectRoot) {
   try {
     return JSON.parse(raw);
   } catch (err) {
+    // Conflict markers are the one way this file usually stops parsing
+    // (change 0242): two branches closed a change each, and git merged the
+    // derived index as text. Said as what it is, with the two ways out.
+    if (/^(<{7}|={7}|>{7})( |$)/m.test(raw)) {
+      throw new Error(".doctrina/index.json carries git's merge conflict markers — it is derived, so `doctrina index rebuild` writes it again from the tree (and `doctrina hooks install` makes git merge it by itself)");
+    }
     throw new Error(`.doctrina/index.json is not valid JSON: ${err.message}`);
   }
 }
@@ -42,7 +48,10 @@ export function save(projectRoot, index) {
   index.framework_version = newestVersion(index.framework_version, cliVersion());
   const p = indexPath(projectRoot);
   const text = JSON.stringify(index, null, 2) + "\n";
-  write(p, text, { force: true });
+  // Atomic (change 0250): every command reads this file, and one that read
+  // it while another was half-way through writing it stopped with
+  // "Unexpected end of JSON input".
+  write(p, text, { force: true, atomic: true });
 }
 
 export function blank(projectName, date) {

package/src/lib/index-merge.js

@@ -0,0 +1,90 @@
+// @ts-check
+import { ARTIFACT_CATEGORIES } from "./index-json.js";
+import { newestVersion } from "./version.js";
+
+// THE INDEX MERGES AS WHAT IT IS: A LIST OF ARTIFACTS (change 0242).
+//
+// `index.json` is one file every change rewrites — a version here, a closed
+// change appended there, the date on top. Two branches that each close a
+// change therefore meet on the same lines, and git, which merges text, stops
+// with conflict markers in a file nobody wrote by hand.
+//
+// Merged as data there is nothing to resolve: an entry one branch added is
+// added, an entry one branch removed is removed, and where both changed the
+// same field the newer value wins — a version only grows, a date only moves
+// forward. What this cannot know (a header edited on both sides) the tree
+// still decides: `doctrina index rebuild` derives the index from the files,
+// and the commit hook runs it.
+
+const key = (/** @type {any} */ entry) => String(entry?.path ?? entry?.id ?? "");
+const same = (/** @type {any} */ a, /** @type {any} */ b) => JSON.stringify(a) === JSON.stringify(b);
+
+/** `1.10.0` over `1.9.0`; anything that is not three numbers compares as text. */
+function laterVersion(a, b) {
+  const parts = (/** @type {string} */ v) => String(v).split(".").map((n) => Number(n));
+  const [x, y] = [parts(a), parts(b)];
+  if (x.some(Number.isNaN) || y.some(Number.isNaN)) return String(a) >= String(b) ? a : b;
+  for (let i = 0; i < Math.max(x.length, y.length); i++) {
+    if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0) ? a : b;
+  }
+  return a;
+}
+
+/** Both sides changed `field` to different values: the one that moved furthest. */
+function settle(field, ours, theirs) {
+  if (field === "framework_version") return newestVersion(ours, theirs);
+  if (field === "version") return laterVersion(ours, theirs);
+  if (/(^|_)(updated|date)$/.test(field)) return String(ours) >= String(theirs) ? ours : theirs;
+  return ours;
+}
+
+/** Three-way merge of one object's fields. */
+function mergeFields(base, ours, theirs) {
+  /** @type {Record<string, any>} */
+  const out = {};
+  for (const field of new Set([...Object.keys(ours ?? {}), ...Object.keys(theirs ?? {})])) {
+    const [b, o, t] = [base?.[field], ours?.[field], theirs?.[field]];
+    let value;
+    if (same(o, t) || same(t, b)) value = o;
+    else if (same(o, b)) value = t;
+    else if (o === undefined || t === undefined) value = o ?? t;
+    else value = settle(field, o, t);
+    if (value !== undefined) out[field] = value;
+  }
+  return out;
+}
+
+/** Three-way merge of one artifact category, in the order a rebuild writes. */
+function mergeList(base, ours, theirs) {
+  const by = (/** @type {any[]} */ list) => new Map((list ?? []).map((e) => [key(e), e]));
+  const [b, o, t] = [by(base), by(ours), by(theirs)];
+  const out = [];
+  for (const k of new Set([...o.keys(), ...t.keys()])) {
+    const [eb, eo, et] = [b.get(k), o.get(k), t.get(k)];
+    if (eo && et) out.push(mergeFields(eb, eo, et));
+    // Present on one side only: added there, or removed on the other. An
+    // entry the base never had was added; one it had was removed — unless
+    // the side that kept it also changed it, which a removal must not erase.
+    else if (!eb) out.push(eo ?? et);
+    else if (!same(eo ?? et, eb)) out.push(eo ?? et);
+  }
+  return out.sort((x, y) => (key(x) < key(y) ? -1 : key(x) > key(y) ? 1 : 0));
+}
+
+/**
+ * Merge two indexes that descend from `base`. Pure: returns the merged index.
+ * @param {any} base  the common ancestor (`{}` when there is none)
+ * @param {any} ours
+ * @param {any} theirs
+ */
+export function mergeIndex(base, ours, theirs) {
+  const out = mergeFields({ ...base, artifacts: undefined }, { ...ours, artifacts: undefined }, { ...theirs, artifacts: undefined });
+  const [ab, ao, at] = [base?.artifacts ?? {}, ours?.artifacts ?? {}, theirs?.artifacts ?? {}];
+  /** @type {Record<string, any>} */
+  const artifacts = {};
+  for (const cat of new Set([...Object.keys(ao), ...Object.keys(at)])) {
+    const list = ARTIFACT_CATEGORIES.includes(cat) || Array.isArray(ao[cat] ?? at[cat]);
+    artifacts[cat] = list ? mergeList(ab[cat], ao[cat], at[cat]) : mergeFields(ab[cat], ao[cat] ?? {}, at[cat] ?? {});
+  }
+  return { ...out, artifacts };
+}

package/src/lib/install.js

@@ -0,0 +1,80 @@
+// @ts-check
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+
+// WHICH `doctrina` A TERMINAL RUNS (change 0243).
+//
+// The hooks the adapters write call `doctrina` by name, so they run whatever
+// the PATH finds first — and a machine with two Node versions, or an npm
+// prefix that moved, holds two installs. `npm install -g` updated one, the
+// PATH still found the other, and `doctrina --version` answered the old
+// number while the registry and the package both said the new one. Nothing
+// in the CLI could say so: it only knew its own version.
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const real = (/** @type {string} */ p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return null;
+  }
+};
+const versionAt = (/** @type {string} */ pkgDir) => {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf8"));
+    return pkg.name === "doctrina-cli" ? String(pkg.version ?? "") : null;
+  } catch {
+    return null;
+  }
+};
+
+/** The package directory of the CLI that is running. */
+export function runningPackageDir() {
+  return real(path.resolve(here, "..", "..")) ?? path.resolve(here, "..", "..");
+}
+
+/**
+ * The package a `doctrina` found in `dir` belongs to: through the symlink npm
+ * writes on POSIX, or beside the `.cmd` shim it writes on Windows.
+ * @returns {{ bin: string, pkgDir: string | null, version: string | null } | null}
+ */
+function installIn(dir, platform) {
+  const names = platform === "win32" ? ["doctrina.cmd", "doctrina.ps1", "doctrina"] : ["doctrina"];
+  const bin = names.map((n) => path.join(dir, n)).find((p) => existsSync(p));
+  if (!bin) return null;
+  const candidates = [];
+  const target = real(bin);
+  // npm on POSIX: bin/doctrina -> ../lib/node_modules/doctrina-cli/src/index.js
+  if (target && target !== bin) candidates.push(path.resolve(path.dirname(target), ".."));
+  candidates.push(path.join(dir, "node_modules", "doctrina-cli"));           // npm on Windows, and a project's .bin
+  candidates.push(path.join(dir, "..", "doctrina-cli"));                     // node_modules/.bin
+  candidates.push(path.join(dir, "..", "lib", "node_modules", "doctrina-cli")); // a POSIX shim that is not a link
+  for (const c of candidates) {
+    const version = versionAt(c);
+    if (version !== null) return { bin, pkgDir: real(c) ?? c, version };
+  }
+  return { bin, pkgDir: null, version: null };
+}
+
+/**
+ * Every `doctrina` the PATH holds, in the order a shell would find them, one
+ * per package. The first is the one a bare `doctrina` runs.
+ * @returns {{ bin: string, pkgDir: string | null, version: string | null, running: boolean }[]}
+ */
+export function installsOnPath(env = process.env, platform = process.platform) {
+  const sep = platform === "win32" ? ";" : ":";
+  const running = runningPackageDir();
+  const seen = new Set();
+  const out = [];
+  for (const dir of String(env.PATH ?? env.Path ?? "").split(sep).filter(Boolean)) {
+    const found = installIn(dir, platform);
+    if (!found) continue;
+    const key = found.pkgDir ?? found.bin;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ ...found, running: found.pkgDir === running });
+  }
+  return out;
+}

package/src/lib/intake-model.js

@@ -55,13 +55,16 @@ export function nextStepAfterInit(intakeFrom) {
       "Next: open your AI agent in this repository and tell it:",
       "    read AGENTS.md and run doctrina next",
       "It turns your description into product.md and specs; you review and approve.",
+      "New to Doctrina? `doctrina onboard` walks the whole cycle once, on this repository.",
     ];
   }
   return [
     "Next: give your AI agent the whole project description. It runs",
     "    doctrina intake --text \"<description>\"",
     "and turns it into product.md and specs (AGENTS.md, \"Working from intent\");",
-    "for an existing codebase, `doctrina work --from-diff` backfills them from the code.",
+    "for an existing codebase, `doctrina intake --from-code` takes its inventory as the intake",
+    "(`doctrina work --from-diff` backfills one change from code already written).",
+    "New to Doctrina? `doctrina onboard` walks the whole cycle once, on this repository.",
   ];
 }
 

package/src/lib/ledger.js

@@ -14,8 +14,7 @@
 // match the grammar is not a corrupt ledger — it is a person writing a note.
 // Such lines are counted, never thrown, and never rewritten.
 import path from "node:path";
-import { appendFileSync } from "node:fs";
-import { exists, isFile, mkdirp, read, write } from "./fs-ops.js";
+import { appendLine, exists, isFile, mkdirp, read, write } from "./fs-ops.js";
 import { today } from "./dates.js";
 
 export const LEDGER_REL = ".doctrina/changes/archive/LEDGER.md";
@@ -157,7 +156,7 @@ export function appendLedgerLine(projectRoot, line) {
     mkdirp(path.dirname(p));
     write(p, HEADER);
   }
-  appendFileSync(p, `${line}\n`);
+  appendLine(p, line);
   return p;
 }
 

package/src/lib/lock.js

@@ -0,0 +1,58 @@
+// @ts-check
+import path from "node:path";
+import { mkdirSync, rmdirSync, statSync } from "node:fs";
+
+// ONE AT A TIME, FOR THE FEW STEPS THAT MUST BE (seventh audit, change 0250).
+//
+// "One writer per repository" is the model; a planner and an executor in the
+// same clone, or an agent that fires its tool calls in parallel, is what
+// happens. Eight `doctrina work` at once opened three changes numbered 0003
+// and two numbered 0004: each read the highest number on disk before any of
+// the others had created its folder.
+//
+// The lock is a directory — `mkdir` either creates it or fails, atomically,
+// on every filesystem this runs on. It is held for milliseconds. A lock left
+// behind by a process that died is taken over once it is old.
+
+const WAIT_MS = 25;
+const GIVE_UP_MS = 5000;
+const STALE_MS = 30000;
+
+function sleep(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+/**
+ * Run `fn` holding the project's lock. If the lock cannot be had in time the
+ * function runs anyway: a stuck lock must never stop the work it protects.
+ * @template T
+ * @param {string} projectRoot
+ * @param {() => T} fn
+ * @returns {T}
+ */
+export function withProjectLock(projectRoot, fn) {
+  const lock = path.join(projectRoot, ".doctrina", ".lock");
+  let held = false;
+  for (let waited = 0; waited <= GIVE_UP_MS; waited += WAIT_MS) {
+    try {
+      mkdirSync(lock);
+      held = true;
+      break;
+    } catch (err) {
+      if (/** @type {NodeJS.ErrnoException} */ (err).code !== "EEXIST") break; // no .doctrina/, read-only tree: nothing to serialise
+      try {
+        if (Date.now() - statSync(lock).mtimeMs > STALE_MS) rmdirSync(lock);
+      } catch { /* released between the two calls */ }
+      sleep(WAIT_MS);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (held) {
+      try {
+        rmdirSync(lock);
+      } catch { /* already gone */ }
+    }
+  }
+}

package/src/lib/merge-setup.js

@@ -0,0 +1,55 @@
+// @ts-check
+import path from "node:path";
+import { exists, read, write } from "./fs-ops.js";
+import { git, GIT_STATE } from "./git.js";
+
+// WHAT A REPOSITORY NEEDS SO TWO BRANCHES MERGE THEIR ARTIFACTS (change 0242).
+//
+// Two files are rewritten by every change, so two branches always meet on
+// them: `index.json`, which is derived, and the ledger, which is a list.
+// `.gitattributes` names how each merges — it is committed, so every clone
+// reads it — and the index's driver is a command, which git keeps in the
+// clone's own config: `doctrina hooks install` writes both.
+
+export const MERGE_DRIVER = "doctrina-index";
+export const ATTRIBUTE_LINES = [
+  `**/.doctrina/index.json merge=${MERGE_DRIVER}`,
+  "**/.doctrina/changes/archive/LEDGER.md merge=union",
+];
+const HEADING = "# Doctrina: the derived index merges as data, the ledger as a list (`doctrina hooks install`)";
+
+/** The lines `.gitattributes` still lacks, in order. */
+export function missingAttributes(projectRoot) {
+  const file = path.join(projectRoot, ".gitattributes");
+  const have = exists(file) ? read(file).split(/\r?\n/).map((l) => l.trim()) : [];
+  return ATTRIBUTE_LINES.filter((line) => !have.includes(line));
+}
+
+/** Append the missing lines to `.gitattributes`. Returns how many were added. */
+export function writeAttributes(projectRoot) {
+  const missing = missingAttributes(projectRoot);
+  if (missing.length === 0) return 0;
+  const file = path.join(projectRoot, ".gitattributes");
+  const before = exists(file) ? read(file) : "";
+  const eol = before.includes("\r\n") ? "\r\n" : "\n";
+  const gap = before === "" || before.endsWith("\n") ? "" : eol;
+  const head = before.includes(HEADING) ? [] : [HEADING];
+  write(file, before + gap + (before === "" ? "" : eol) + [...head, ...missing].join(eol) + eol, { force: true });
+  return missing.length;
+}
+
+/** The driver command this clone runs for the index, or null when it has none. */
+export function configuredDriver(projectRoot) {
+  const r = git(projectRoot, ["config", "--get", `merge.${MERGE_DRIVER}.driver`]);
+  return r.state === GIT_STATE.OK && r.stdout.trim() !== "" ? r.stdout.trim() : null;
+}
+
+/**
+ * Point this clone's merge driver at `command` (the CLI, pinned by path as
+ * the hook is). Returns false when git refused.
+ */
+export function configureDriver(projectRoot, command) {
+  const set = (/** @type {string} */ k, /** @type {string} */ v) =>
+    git(projectRoot, ["config", `merge.${MERGE_DRIVER}.${k}`, v]).state === GIT_STATE.OK;
+  return set("name", "Doctrina index merge") && set("driver", `${command} index merge %O %A %B`);
+}

package/src/lib/metrics-model.js

@@ -90,7 +90,7 @@ export function parseLog(stdout) {
   for (const line of stdout.split("\n")) {
     if (line.startsWith("@@")) {
       const [hash, ts, ...rest] = line.slice(2).split("|");
-      current = { hash, ts: Number(ts), subject: rest.join("|"), files: [] };
+      current = { hash, ts: Number(ts), subject: rest.join("|"), files: /** @type {string[]} */ ([]) };
       commits.push(current);
     } else if (line.trim() !== "" && current) {
       current.files.push(line.trim());
@@ -181,7 +181,7 @@ export function readSeries(projectRoot) {
 }
 
 /** The most recent saved snapshot, excluding one basename. */
-export function latestSnapshot(projectRoot, excludeBase = null) {
+export function latestSnapshot(projectRoot, excludeBase = /** @type {string | null} */ (null)) {
   const series = readSeries(projectRoot).filter((s) => `${s.generated}.json` !== excludeBase);
   return series.length > 0 ? series[series.length - 1] : null;
 }