kryptheon 0.1.10 → 0.1.11

package/bin/kryptheon.js

@@ -17,6 +17,8 @@ const replay = require('../kryptheon-replay.js');
 const selectors = require('../kryptheon-selectors.js');
 const recordings = require('../kryptheon-recordings.js');
 const cleanup = require('../kryptheon-cleanup.js');
+const baselines = require('../kryptheon-baselines.js');
+const project = require('../kryptheon-project.js');
 
 const PACKAGE_DIR = path.join(__dirname, '..');
 const USER_DIR = process.cwd();
@@ -1009,6 +1011,39 @@ async function offerToDropLogout(relativeFile) {
 // corrected on the second attempt becomes a wrong login performed on every
 // run. This takes those out and says what it took, because a tool that edits
 // your recording without telling you is worse than one that leaves the mess.
+// A saved result whose recording is gone, or has been recorded again since,
+// describes a page nothing here visits any more. Left in place it is handed
+// to whichever new recording lands on the same name, which then fails on its
+// first run against a baseline it never created.
+function dropDeadBaselines() {
+  const api = (function () {
+    try {
+      return require(path.join(PACKAGE_DIR, 'kryptheon-fixture.js'));
+    } catch (err) {
+      return null;
+    }
+  })();
+  if (!api) return [];
+
+  let all;
+  try {
+    all = api.readBaselines(api.BASELINE_FILE);
+  } catch (err) {
+    return [];
+  }
+  if (!all || !Object.keys(all).length) return [];
+
+  const result = baselines.pruneBaselines(all, USER_DIR);
+  if (!result.changed) return [];
+  try {
+    fs.writeFileSync(api.BASELINE_FILE, JSON.stringify(result.baselines, null, 2) + String.fromCharCode(10), "utf8");
+  } catch (err) {
+    return [];
+  }
+  for (const line of baselines.pruneLines(result.dropped)) console.log(line);
+  return result.dropped;
+}
+
 function tidyRecording(relativeFile) {
   const source = readSpec(relativeFile);
   if (source === null) return [];
@@ -1490,22 +1525,23 @@ function triageSpecs() {
 
 function check(options) {
   const quiet = !!(options && options.quiet);
+
+  // Before anything else. Recordings and results are read out of whatever
+  // folder this was run in, so being in the wrong one does not fail - it
+  // succeeds, about the wrong project. That is the one outcome worth exiting
+  // non-zero over even though nothing was tested.
+  const here = project.inspectProject(USER_DIR);
+  if (!here.ok) {
+    for (const line of project.noProjectLines(here)) console.error(line);
+    return 1;
+  }
+
   // Deliberately not a failure. An assistant told to run this after every
   // change will read a non-zero exit as "something broke" and start fixing
   // code that is perfectly fine. Nothing has been recorded, so there is
   // nothing to verify and nothing to repair.
   if (!listSpecFiles().length) {
-    console.log('');
-    console.log('  Nothing has been recorded yet, so there is nothing to check.');
-    console.log('');
-    console.log('  This is not a failure, and there is nothing in the code to fix.');
-    console.log('');
-    console.log('  To start, record a flow through the app:');
-    console.log('    npx kryptheon record <url>');
-    console.log('');
-    console.log('  That opens a browser window, so it has to be run by a person in');
-    console.log('  a normal terminal - it cannot be done from an AI assistant.');
-    console.log('');
+    for (const line of project.noRecordingsLines()) console.log(line);
     return 0;
   }
   if (!fixtureResolvesForUser() && specsNeedThePackage()) {
@@ -1522,6 +1558,7 @@ function check(options) {
     return 1;
   }
   keepArtefactsOutOfGit();
+  dropDeadBaselines();
 
   const triage = triageSpecs();
 
@@ -1933,6 +1970,7 @@ module.exports = {
   codegenComplaints: codegenComplaints,
   reportFragileSelectors: reportFragileSelectors,
   tidyRecording: tidyRecording,
+  dropDeadBaselines: dropDeadBaselines,
   reportTidying: reportTidying,
   remove: remove,
   deleteRecording: deleteRecording,

package/kryptheon-baselines.js

@@ -0,0 +1,176 @@
+// Keeping a saved result tied to the recording it came from.
+//
+// A baseline used to be identified by where the recording lived and what it was
+// called. That is not enough. Delete the spec files with `del tests\*.spec.js` -
+// which is what anyone does before the tool has taught them `kryptheon remove` -
+// record the flow again, and the new recording is handed the same name. Same
+// path, same title, same key. It inherits the old recording's saved page and
+// fails on its very first run, against a baseline it never created and could
+// never have matched.
+//
+// The report that came out of that said both of these at once:
+//
+//   This has not passed before.
+//   Headings that are gone: "Transactions"
+//
+// Which cannot both be true. If it has never passed there is no baseline of its
+// own to have changed, so there is nothing to show a difference against.
+//
+// So a saved result now also records a fingerprint of the recording that made
+// it. When the recording is gone, or its steps are not the steps the baseline
+// was taken from, the saved result describes something that no longer exists
+// and is thrown away rather than compared against.
+//
+// Pure data work: no Playwright, no test runner.
+
+const fs = require('fs');
+const path = require('path');
+const replay = require('./kryptheon-replay.js');
+
+/** The spec file half of a baseline key, in one consistent shape. */
+function specOf(key) {
+  return String(key || '').split(' :: ')[0].split('\\').join('/');
+}
+
+function titleOf(key) {
+  const parts = String(key || '').split(' :: ');
+  return parts.length > 1 ? parts.slice(1).join(' :: ') : '';
+}
+
+/** The fingerprint of the recording in a file, or null if it cannot be read. */
+function fingerprintOf(userDir, specPath) {
+  let source;
+  try {
+    source = fs.readFileSync(path.join(userDir, specPath), 'utf8');
+  } catch (e) {
+    return null;
+  }
+  return replay.recordingId(source);
+}
+
+/**
+ * What each saved result is: still current, orphaned, or stale.
+ *
+ * `orphan`  - the recording it belongs to is not there any more.
+ * `stale`   - a recording of that name exists, but it is not the one this was
+ *             taken from. This is the case that cost twenty minutes: the file
+ *             is present, so nothing looks wrong.
+ * `legacy`  - written before fingerprints existed. There is no way to tell
+ *             whether it matches, so it is kept, and a fingerprint is written
+ *             in so the question can be answered next time. Guessing here would
+ *             mean either throwing away a good baseline or, far worse, quietly
+ *             accepting a real regression as the new normal.
+ */
+function classifyBaselines(baselines, userDir) {
+  const all = baselines || {};
+  const verdicts = [];
+
+  for (const key of Object.keys(all)) {
+    const entry = all[key];
+    const spec = specOf(key);
+    if (!entry || typeof entry !== 'object') {
+      verdicts.push({ key: key, state: 'orphan', spec: spec, title: titleOf(key) });
+      continue;
+    }
+
+    let exists = false;
+    try {
+      exists = fs.statSync(path.join(userDir, spec)).isFile();
+    } catch (e) {
+      exists = false;
+    }
+    if (!exists) {
+      verdicts.push({ key: key, state: 'orphan', spec: spec, title: titleOf(key) });
+      continue;
+    }
+
+    const now = fingerprintOf(userDir, spec);
+    if (!entry.recordingId) {
+      verdicts.push({ key: key, state: 'legacy', spec: spec, title: titleOf(key), fingerprint: now });
+      continue;
+    }
+    if (now && entry.recordingId !== now) {
+      verdicts.push({ key: key, state: 'stale', spec: spec, title: titleOf(key), fingerprint: now });
+      continue;
+    }
+    verdicts.push({ key: key, state: 'current', spec: spec, title: titleOf(key) });
+  }
+
+  return verdicts;
+}
+
+/**
+ * The saved results with the dead ones taken out.
+ *
+ * Returns a new object; nothing is written here. The caller decides whether the
+ * file is worth rewriting, so a check that changes nothing never touches it.
+ */
+function pruneBaselines(baselines, userDir) {
+  const all = baselines || {};
+  const verdicts = classifyBaselines(all, userDir);
+  const kept = {};
+  const dropped = [];
+  let stamped = 0;
+
+  for (const verdict of verdicts) {
+    if (verdict.state === 'orphan' || verdict.state === 'stale') {
+      dropped.push(verdict);
+      continue;
+    }
+    const entry = all[verdict.key];
+    if (verdict.state === 'legacy' && verdict.fingerprint) {
+      // Kept as it is, but tied to this recording from now on.
+      kept[verdict.key] = Object.assign({}, entry, { recordingId: verdict.fingerprint });
+      stamped++;
+      continue;
+    }
+    kept[verdict.key] = entry;
+  }
+
+  return { baselines: kept, dropped: dropped, stamped: stamped, changed: dropped.length > 0 || stamped > 0 };
+}
+
+function plural(n, word) {
+  return n + ' ' + word + (n === 1 ? '' : 's');
+}
+
+/**
+ * One line about what was thrown away, said as a fact rather than a warning.
+ *
+ * Nothing has gone wrong when this happens - a recording was deleted or redone,
+ * which is a normal thing to do. It is said out loud only so that a flow which
+ * suddenly starts from scratch is not a mystery.
+ */
+function pruneLines(dropped) {
+  const list = dropped || [];
+  if (!list.length) return [];
+
+  const orphans = list.filter((d) => d.state === 'orphan');
+  const stale = list.filter((d) => d.state === 'stale');
+  const lines = [];
+
+  if (orphans.length) {
+    lines.push(
+      '  ' + plural(orphans.length, 'old baseline') + ' removed - ' +
+        (orphans.length === 1 ? 'its recording is' : 'their recordings are') + ' no longer here.',
+    );
+  }
+  if (stale.length) {
+    lines.push(
+      '  ' + plural(stale.length, 'old baseline') + ' removed - ' +
+        (stale.length === 1 ? 'its recording has' : 'those recordings have') +
+        ' been recorded again since.',
+    );
+  }
+  lines.push('');
+  return lines;
+}
+
+module.exports = {
+  specOf: specOf,
+  titleOf: titleOf,
+  fingerprintOf: fingerprintOf,
+  classifyBaselines: classifyBaselines,
+  pruneBaselines: pruneBaselines,
+  pruneLines: pruneLines,
+};

package/kryptheon-fixture.js

@@ -20,7 +20,8 @@ const base = require('@playwright/test');
 // Reuse the reporter's host-stripping so a baseline stores exactly the shape
 // the reporter prints.
 const { requestPath } = require('./kryptheon-reporter.js');
-const signature = require('./kryptheon-signature.js');
+const signature = require('./kryptheon-signature.js');
+const replay = require('./kryptheon-replay.js');
 
 const MAX_ITEMS = 5; // keep the failure block readable
 
@@ -128,6 +129,10 @@ function normalisedEntry(current) {
   // Only when there is one. A run whose capture failed must not write an empty
   // signature over a good one, or the next run would report everything as gone.
   if (current.signature) stored.signature = current.signature;
+  // What recording this was taken from. Without it, a saved result is tied
+  // only to a file name, and a re-recording that lands on the same name
+  // inherits a baseline it never created and can never match.
+  if (current.recordingId) stored.recordingId = current.recordingId;
   return stored;
 }
 
@@ -232,6 +237,17 @@ function newObservations(current, previous) {
 // Adds a signature to an accepted baseline that predates the feature, without
 // touching anything else about it - including when it was recorded, which is
 // what the failure report means by "this last worked at".
+// Ties a saved result written before fingerprints existed to the recording it
+// is now being compared against. Only ever on a pass, so an entry is never
+// bound to a run that did not match it.
+function stampRecording(file, key, recordingId) {
+  const all = readBaselines(file);
+  const entry = all[key];
+  if (!entry || typeof entry !== 'object' || entry.recordingId || !recordingId) return false;
+  entry.recordingId = recordingId;
+  return saveBaselines(file, all);
+}
+
 function upgradeBaseline(file, key, sig) {
   const all = readBaselines(file);
   const entry = all[key];
@@ -247,6 +263,17 @@ function applyBaseline(file, key, current) {
     writeBaseline(file, key, current);
     return { status: 'created', message: null };
   }
+
+  // A saved result taken from a different recording describes a page this
+  // flow never visited. Comparing against it produces a failure on the first
+  // run that no amount of fixing the app can clear, so it is replaced rather
+  // than argued with. Only when both fingerprints are known: an entry from
+  // before they existed is left alone, because "cannot tell" must never
+  // become "accept whatever this run saw".
+  if (previous.recordingId && current.recordingId && previous.recordingId !== current.recordingId) {
+    writeBaseline(file, key, current);
+    return { status: 'created', message: null };
+  }
   const message = compareBaselines(previous, current);
   if (message) return { status: 'changed', message: message };
 
@@ -257,6 +284,10 @@ function applyBaseline(file, key, current) {
     upgradeBaseline(file, key, current.signature);
     return { status: 'learned', message: null };
   }
+  if (!previous.recordingId && current.recordingId) {
+    stampRecording(file, key, current.recordingId);
+    return { status: 'learned', message: null };
+  }
   return { status: 'match', message: null };
 }
 
@@ -283,6 +314,17 @@ const test = base.test.extend({
 
     const key = baselineKey(testInfo.file, testInfo.title);
 
+    // The steps this recording actually performs. Comments, blank lines and
+    // the test name are ignored, so tidying a file does not read as a
+    // different recording - only changing what it does.
+    const recordingId = (function () {
+      try {
+        return replay.recordingId(fs.readFileSync(testInfo.file, 'utf8'));
+      } catch (e) {
+        return null;
+      }
+    })();
+
     // Reports only what this run added on top of the last passing run.
     const attachObservations = async () => {
       let url = null;
@@ -351,6 +393,7 @@ const test = base.test.extend({
         consoleErrors: consoleErrors,
         failedRequests: failedRequests,
         signature: captured,
+        recordingId: recordingId,
       };
     } catch (e) {
       current = null; // page closed by the test - leave any baseline untouched
@@ -384,5 +427,6 @@ module.exports = {
   compareBaselines: compareBaselines,
   applyBaseline: applyBaseline,
   upgradeBaseline: upgradeBaseline,
+  stampRecording: stampRecording,
   BASELINE_FILE: BASELINE_FILE,
 };

package/kryptheon-project.js

@@ -0,0 +1,199 @@
+// Working out whether this folder is a project at all.
+//
+// `kryptheon check` reads recordings out of ./tests and baselines out of the
+// folder it was run in. Run it somewhere that is not a project - a home folder,
+// the place a global install happened to leave you - and it will happily find
+// whatever tests/ happens to be lying around and run those instead, reporting
+// results for a project nobody asked about. That has already happened to
+// somebody who installed into their home folder.
+//
+// Quietly testing the wrong project is the worst thing this tool can do. A
+// green that belongs to something else is not a result, it is a lie with a tick
+// next to it. So the answer to "is this a project?" has to be settled before
+// anything runs, and the answer has to be a stop rather than a guess.
+//
+// Pure path work: nothing here runs a test or reads a recording.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// For someone who genuinely keeps recordings outside a package. Deliberately
+// long-winded: it should be something you decide to type, not something you
+// stumble into.
+const ESCAPE_HATCH = 'KRYPTHEON_ALLOW_NO_PACKAGE_JSON';
+
+function hasPackageJson(dir) {
+  try {
+    return fs.statSync(path.join(dir, 'package.json')).isFile();
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * One comparable form of a path.
+ *
+ * The trailing separator has to go or C:\Users and C:\Users\ never match, but
+ * it must not be taken off before the root test below. "C:" without a separator
+ * is not the drive - Node resolves it to the current directory - so a root
+ * compared in this form would quietly become "wherever I happen to be".
+ */
+function tidy(dir) {
+  return path.resolve(String(dir || '')).replace(/[\\/]+$/, '').toLowerCase();
+}
+
+/** The folders that are somebody's whole account or the machine itself. */
+function isHomeOrSystem(dir) {
+  // A drive or filesystem root: C:\, D:\, /. Done on the resolved path, with
+  // its separator still on, for the reason above.
+  const resolved = path.resolve(String(dir || ''));
+  if (resolved === path.parse(resolved).root) return true;
+
+  const here = tidy(dir);
+  if (here === tidy(os.homedir())) return true;
+
+  for (const candidate of systemFolders()) {
+    if (here === tidy(candidate)) return true;
+  }
+  return false;
+}
+
+/**
+ * Every folder that belongs to the machine or to an account rather than to a
+ * project, resolved.
+ *
+ * The first two entries are derived from the running system; the literals after
+ * them are fallbacks for the usual layouts. They overlap - on Windows
+ * USERPROFILE is the home folder and "/Users" resolves to C:\Users - and the
+ * overlap is deliberate: a machine whose home is somewhere unusual is covered
+ * by the derived pair, and a machine whose environment is missing entries is
+ * covered by the literals.
+ */
+function systemFolders() {
+  return [
+    // The folder every account lives in - C:\Users, /home, /Users. On its own
+    // it has no package.json so it would be refused anyway, but one stray npm
+    // install there and it would look exactly like a project.
+    path.dirname(os.homedir()),
+    process.env.SystemRoot,
+    process.env.ProgramFiles,
+    process.env['ProgramFiles(x86)'],
+    process.env.ProgramData,
+    process.env.APPDATA,
+    process.env.LOCALAPPDATA,
+    process.env.USERPROFILE,
+    '/root',
+    '/home',
+    '/Users',
+    '/usr',
+    '/etc',
+    '/bin',
+    '/var',
+    '/opt',
+  ].filter(Boolean);
+}
+
+/**
+ * Whether this folder can be checked, and if not, why not.
+ *
+ * `allowed` is the escape hatch having been set. It is reported rather than
+ * hidden, so a run that only worked because of it says so.
+ */
+function inspectProject(dir, env) {
+  const environment = env || process.env;
+  const allowed = String(environment[ESCAPE_HATCH] || '') !== '';
+  const packaged = hasPackageJson(dir);
+  const personal = isHomeOrSystem(dir);
+  const base = { dir: dir, packaged: packaged, personal: personal, allowed: allowed };
+
+  if (allowed) return Object.assign({ ok: true, reason: null }, base);
+
+  // A home folder is refused even when it has a package.json, and this is not
+  // belt and braces - it is the case that actually happened. Someone installed
+  // the tool into their home folder, so npm left a package.json and a
+  // node_modules there, and a tests folder alongside them. Every sign this
+  // could look for says "project"; none of them is true. The measured state of
+  // one real machine: C:\Users\<name> holding package.json, node_modules and
+  // tests, none of which belong to anything.
+  if (personal) return Object.assign({ ok: false, reason: 'personal' }, base);
+  if (!packaged) return Object.assign({ ok: false, reason: 'no-package' }, base);
+  return Object.assign({ ok: true, reason: null }, base);
+}
+
+/**
+ * Why this folder is not a project, and what to do instead.
+ *
+ * The folder is printed back because the commonest version of this is not
+ * knowing where you are - a new terminal, a global install, a shell that opened
+ * somewhere else.
+ */
+function noProjectLines(inspection) {
+  const lines = [''];
+
+  if (inspection.personal) {
+    lines.push('  This is your home or a system folder, not a project.');
+    lines.push('');
+    lines.push('  You are in:  ' + inspection.dir);
+    lines.push('');
+    // Almost never deliberate, and the one place where running anyway does the
+    // most damage. Said explicitly because a home folder that has had anything
+    // installed into it looks exactly like a project from the outside.
+    lines.push('  Recordings and results are kept beside the app they belong to,');
+    lines.push('  so running here would check whichever tests folder happens to be');
+    lines.push('  sitting in this one - almost certainly not the one you meant.');
+    if (inspection.packaged) {
+      lines.push('');
+      // Said plainly, because otherwise the package.json sitting right there
+      // makes this message look like the bug rather than the diagnosis.
+      lines.push('  There is a package.json here, but that is not what makes a project.');
+      lines.push('  It looks like npm install was run in this folder by mistake, which');
+      lines.push('  leaves a package.json and a node_modules behind.');
+    }
+    lines.push('');
+  } else {
+    lines.push('  There is no project here - this folder has no package.json.');
+    lines.push('');
+    lines.push('  You are in:  ' + inspection.dir);
+    lines.push('');
+  }
+
+  lines.push('  Change into your project folder and run this again:');
+  lines.push('');
+  lines.push('    cd path\\to\\your\\project');
+  lines.push('    kryptheon check');
+  lines.push('');
+  lines.push('  If you really do keep recordings outside a package, set');
+  lines.push('  ' + ESCAPE_HATCH + '=1 and this will run anyway.');
+  lines.push('');
+  return lines;
+}
+
+/** A real project, with nothing recorded in it yet. */
+function noRecordingsLines() {
+  return [
+    '',
+    '  No recordings were found in this project.',
+    '',
+    '  This is not a failure, and there is nothing in the code to fix.',
+    '',
+    '  Record a flow through your app first:',
+    '',
+    '    kryptheon record http://localhost:3000',
+    '',
+    '  That opens a browser window, so it has to be run by a person in a',
+    '  normal terminal - it cannot be done from an AI assistant.',
+    '',
+  ];
+}
+
+module.exports = {
+  ESCAPE_HATCH: ESCAPE_HATCH,
+  hasPackageJson: hasPackageJson,
+  systemFolders: systemFolders,
+  tidy: tidy,
+  isHomeOrSystem: isHomeOrSystem,
+  inspectProject: inspectProject,
+  noProjectLines: noProjectLines,
+  noRecordingsLines: noRecordingsLines,
+};

package/kryptheon-reporter.js

@@ -726,7 +726,14 @@ class KryptheonReporter {
     out.push('X  ' + test.title);
     out.push('   ' + translated.reason);
 
-    for (const detail of translated.details || []) out.push('   ' + detail);
+    // A difference against a baseline only means something if there is a
+    // baseline of this recording's own to differ from. Saying "this has not
+    // passed before" and then listing headings that are gone says two things
+    // that cannot both be true, and the reader spends their time trying to
+    // reconcile them instead of reading the actual failure.
+    const aboutBaseline = /Baseline changed|ended up somewhere different/.test(translated.reason || '');
+    const details = lastPass || !aboutBaseline ? translated.details || [] : [];
+    for (const detail of details) out.push('   ' + detail);
 
     out.push(lastPass ? '   This was working on ' + formatWhen(lastPass) + '.' : '   This has not passed before.');
 

package/package.json

@@ -1,67 +1,71 @@
-{
-  "name": "kryptheon",
-  "version": "0.1.10",
-  "description": "Record what you do in your app and get plain-language reports when it breaks.",
-  "license": "MIT",
-  "type": "commonjs",
-  "bin": {
-    "kryptheon": "bin/kryptheon.js"
-  },
-  "exports": {
-    ".": "./kryptheon-fixture.js",
-    "./kryptheon-fixture": "./kryptheon-fixture.js",
-    "./kryptheon-reporter": "./kryptheon-reporter.js",
-    "./package.json": "./package.json",
-    "./kryptheon-replay": "./kryptheon-replay.js",
-    "./kryptheon-signature": "./kryptheon-signature.js",
-    "./kryptheon-secrets": "./kryptheon-secrets.js"
-  },
-  "files": [
-    "bin/",
-    "kryptheon-fixture.js",
-    "kryptheon-reporter.js",
-    "kryptheon-signature.js",
-    "kryptheon-secrets.js",
-    "playwright.config.js",
-    "README.md",
-    "kryptheon-replay.js",
-    "kryptheon-selectors.js",
-    "kryptheon-recordings.js",
-    "kryptheon-cleanup.js"
-  ],
-  "engines": {
-    "node": ">=20.6.0"
-  },
-  "dependencies": {
-    "@playwright/test": "^1.62.1"
-  },
-  "scripts": {
-    "check": "node kryptheon-reporter.check.js && node kryptheon-signature.check.js && node kryptheon-signature.stream.check.js && node kryptheon-signature.baseline.check.js && node kryptheon-signature.settle.check.js && node kryptheon-signature.number.check.js && node kryptheon-step3.check.js && node kryptheon-watchdog.check.js && node kryptheon-record.check.js && node kryptheon-selectors.check.js && node kryptheon-recordings.check.js && node kryptheon-cleanup.check.js && node kryptheon-package.check.js",
-    "check:stream": "node kryptheon-signature.stream.check.js",
-    "check:baseline": "node kryptheon-signature.baseline.check.js",
-    "check:settle": "node kryptheon-signature.settle.check.js",
-    "check:step3": "node kryptheon-step3.check.js",
-    "check:watchdog": "node kryptheon-watchdog.check.js",
-    "check:record": "node kryptheon-record.check.js",
-    "check:package": "node kryptheon-package.check.js",
-    "prepublishOnly": "node kryptheon-package.check.js",
-    "check:selectors": "node kryptheon-selectors.check.js",
-    "check:number": "node kryptheon-signature.number.check.js",
-    "check:recordings": "node kryptheon-recordings.check.js",
-    "check:cleanup": "node kryptheon-cleanup.check.js"
-  },
-  "keywords": [
-    "playwright",
-    "testing",
-    "end-to-end",
-    "cli"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jhashantanu987-beep/kryptheon-cli.git"
-  },
-  "bugs": {
-    "url": "https://github.com/jhashantanu987-beep/kryptheon-cli/issues"
-  },
-  "homepage": "https://github.com/jhashantanu987-beep/kryptheon-cli#readme"
-}
+{
+  "name": "kryptheon",
+  "version": "0.1.11",
+  "description": "Record what you do in your app and get plain-language reports when it breaks.",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "kryptheon": "bin/kryptheon.js"
+  },
+  "exports": {
+    ".": "./kryptheon-fixture.js",
+    "./kryptheon-fixture": "./kryptheon-fixture.js",
+    "./kryptheon-reporter": "./kryptheon-reporter.js",
+    "./package.json": "./package.json",
+    "./kryptheon-replay": "./kryptheon-replay.js",
+    "./kryptheon-signature": "./kryptheon-signature.js",
+    "./kryptheon-secrets": "./kryptheon-secrets.js"
+  },
+  "files": [
+    "bin/",
+    "kryptheon-fixture.js",
+    "kryptheon-reporter.js",
+    "kryptheon-signature.js",
+    "kryptheon-secrets.js",
+    "playwright.config.js",
+    "README.md",
+    "kryptheon-replay.js",
+    "kryptheon-selectors.js",
+    "kryptheon-recordings.js",
+    "kryptheon-cleanup.js",
+    "kryptheon-baselines.js",
+    "kryptheon-project.js"
+  ],
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "dependencies": {
+    "@playwright/test": "^1.62.1"
+  },
+  "scripts": {
+    "check": "node kryptheon-reporter.check.js && node kryptheon-signature.check.js && node kryptheon-signature.stream.check.js && node kryptheon-signature.baseline.check.js && node kryptheon-signature.settle.check.js && node kryptheon-signature.number.check.js && node kryptheon-step3.check.js && node kryptheon-watchdog.check.js && node kryptheon-record.check.js && node kryptheon-selectors.check.js && node kryptheon-recordings.check.js && node kryptheon-cleanup.check.js && node kryptheon-orphan.check.js && node kryptheon-project.check.js && node kryptheon-package.check.js",
+    "check:stream": "node kryptheon-signature.stream.check.js",
+    "check:baseline": "node kryptheon-signature.baseline.check.js",
+    "check:settle": "node kryptheon-signature.settle.check.js",
+    "check:step3": "node kryptheon-step3.check.js",
+    "check:watchdog": "node kryptheon-watchdog.check.js",
+    "check:record": "node kryptheon-record.check.js",
+    "check:package": "node kryptheon-package.check.js",
+    "prepublishOnly": "node kryptheon-package.check.js",
+    "check:selectors": "node kryptheon-selectors.check.js",
+    "check:number": "node kryptheon-signature.number.check.js",
+    "check:recordings": "node kryptheon-recordings.check.js",
+    "check:cleanup": "node kryptheon-cleanup.check.js",
+    "check:orphan": "node kryptheon-orphan.check.js",
+    "check:project": "node kryptheon-project.check.js"
+  },
+  "keywords": [
+    "playwright",
+    "testing",
+    "end-to-end",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jhashantanu987-beep/kryptheon-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jhashantanu987-beep/kryptheon-cli/issues"
+  },
+  "homepage": "https://github.com/jhashantanu987-beep/kryptheon-cli#readme"
+}