@elench/testkit 0.1.114 → 0.1.116

package/lib/database/schema-source.mjs

@@ -0,0 +1,295 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execa } from "execa";
+import { resolveServiceCwd } from "../config/paths.mjs";
+import { buildExecutionEnv } from "../runner/template.mjs";
+import { dumpPostgresSchemaToFile, captureTemplateSnapshotText, runTemplateStep, sanitizeSnapshotText } from "./template-steps.mjs";
+
+const SOURCE_SCHEMA_DIR = path.join(".testkit", "db");
+const SOURCE_SCHEMA_FILE = "source-schema.sql";
+const SOURCE_SCHEMA_META_FILE = "source-schema.meta.json";
+
+export function getSourceSchemaCachePath(config) {
+  const configured = config.testkit.database?.sourceSchema?.cachePath || null;
+  return configured
+    ? resolveServiceCwd(config.productDir, configured)
+    : path.join(config.productDir, SOURCE_SCHEMA_DIR, config.name, SOURCE_SCHEMA_FILE);
+}
+
+export function getSourceSchemaMetadataPath(config) {
+  const cachePath = getSourceSchemaCachePath(config);
+  return path.join(path.dirname(cachePath), SOURCE_SCHEMA_META_FILE);
+}
+
+export function resolveSourceSchemaState(config, options = {}) {
+  const sourceSchema = config.testkit.database?.sourceSchema || null;
+  if (!sourceSchema) return { active: false };
+
+  const cachePath = getSourceSchemaCachePath(config);
+  const cacheExists = fs.existsSync(cachePath);
+  const env = buildExecutionEnv(config, {}, options.env || process.env);
+  const envNames = sourceSchema.kind === "env"
+    ? [sourceSchema.env]
+    : [serviceSourceSchemaEnvName(config.name), "TESTKIT_SCHEMA_SOURCE_DATABASE_URL"];
+  const envName = envNames.find((name) => typeof env[name] === "string" && env[name].trim().length > 0) || null;
+  const sourceUrl = envName ? env[envName].trim() : null;
+  const explicit = sourceSchema.kind === "env";
+  const active = explicit || Boolean(sourceUrl) || cacheExists;
+  if (!active) return { active: false, cachePath };
+
+  return {
+    active: true,
+    cachePath,
+    metadataPath: getSourceSchemaMetadataPath(config),
+    envName,
+    sourceUrl,
+    sourceSchema,
+    cacheExists,
+    refreshed: false,
+    unavailableMode: resolveUnavailableMode(sourceSchema.unavailable, options.env || process.env),
+  };
+}
+
+export async function prepareSourceSchemaCache(config, options = {}) {
+  const state = resolveSourceSchemaState(config, options);
+  if (!state.active) return state;
+
+  if (state.sourceUrl) {
+    if (shouldRefreshSourceSchema(state)) {
+      await refreshSourceSchemaCache(config, state, options);
+      return { ...state, refreshed: true, cacheExists: true };
+    }
+    options.setupRegistry?.recordCached({
+      config,
+      stage: "source-schema",
+      kind: "database-source-schema",
+      summary: "source schema cache hit",
+    });
+    return state;
+  }
+
+  if (state.cacheExists && state.unavailableMode === "warn-cache") {
+    options.setupRegistry?.recordCached({
+      config,
+      stage: "source-schema",
+      kind: "database-source-schema",
+      summary: "source unavailable; using cached source schema",
+    });
+    return state;
+  }
+
+  const envLabel = state.sourceSchema.kind === "env"
+    ? state.sourceSchema.env
+    : `${serviceSourceSchemaEnvName(config.name)} or TESTKIT_SCHEMA_SOURCE_DATABASE_URL`;
+  throw new Error(
+    `Source schema database URL is unavailable for service "${config.name}". Set ${envLabel}.`
+  );
+}
+
+export async function forceRefreshSourceSchemaCache(config, previousState, options = {}) {
+  const state = resolveSourceSchemaState(config, options);
+  if (!state.active || !state.sourceUrl) {
+    const envLabel = previousState?.envName || previousState?.sourceSchema?.env || "source schema env";
+    throw new Error(`Cannot refresh source schema for service "${config.name}" because ${envLabel} is unavailable.`);
+  }
+  await refreshSourceSchemaCache(config, state, options);
+  return { ...state, refreshed: true, cacheExists: true };
+}
+
+export async function applySourceSchemaCache(config, databaseUrl, state, options = {}) {
+  if (!state?.active) return false;
+  if (!fs.existsSync(state.cachePath)) {
+    throw new Error(`Missing source schema cache for service "${config.name}": ${state.cachePath}`);
+  }
+  await runTemplateStep(
+    config,
+    "source-schema",
+    {
+      kind: "sql-file",
+      path: path.relative(config.productDir, state.cachePath).split(path.sep).join("/"),
+      cwd: null,
+      inputs: [],
+    },
+    0,
+    databaseUrl,
+    options
+  );
+  return true;
+}
+
+export async function verifyLocalSchemaMatchesSource(config, databaseUrl, state, options = {}) {
+  if (!state?.active) return { status: "disabled" };
+  if (state.sourceSchema.verify === false || options.skipSchemaSourceVerify) {
+    options.setupRegistry?.recordCached({
+      config,
+      stage: "source-schema:verify",
+      kind: "database-source-schema",
+      summary: "source schema verification skipped",
+    });
+    return { status: "skipped" };
+  }
+
+  const sourceSchema = readSourceSchemaCacheText(state.cachePath);
+  const localSchema = await captureTemplateSnapshotText(config, databaseUrl, {
+    reporter: options.reporter || null,
+  });
+  if (localSchema === sourceSchema) {
+    return { status: "matched" };
+  }
+
+  const diagnostics = await writeSchemaMismatchDiagnostics(config, state.cachePath, sourceSchema, localSchema);
+  return {
+    status: "mismatch",
+    diagnostics,
+  };
+}
+
+export function createSourceSchemaMismatchError(config, state, verification) {
+  const parts = [
+    `Local schema replay does not match source schema for service "${config.name}".`,
+    `Source cache: ${path.relative(config.productDir, state.cachePath)}`,
+  ];
+  if (verification?.diagnostics?.diffPath) {
+    parts.push(`Diff: ${path.relative(config.productDir, verification.diagnostics.diffPath)}`);
+  }
+  return new Error(parts.join("\n"));
+}
+
+export function appendSourceSchemaCacheToHash(hash, config) {
+  const sourceSchema = config.testkit.database?.sourceSchema || null;
+  if (!sourceSchema) return;
+  const cachePath = getSourceSchemaCachePath(config);
+  hash.update(`source-schema-cache:${path.relative(config.productDir, cachePath)}`);
+  if (!fs.existsSync(cachePath)) {
+    hash.update(":missing");
+    return;
+  }
+  const stat = fs.statSync(cachePath);
+  hash.update(`:${stat.size}:${stat.mtimeMs}`);
+  hash.update(fs.readFileSync(cachePath));
+}
+
+async function refreshSourceSchemaCache(config, state, options = {}) {
+  const operation = options.setupRegistry?.start({
+    config,
+    stage: "source-schema:refresh",
+    kind: "database-source-schema",
+    summary: `source schema refresh: ${path.relative(config.productDir, state.cachePath)}`,
+  });
+  try {
+    await writeSourceSchemaCacheFromUrl(config, state.sourceUrl, state.cachePath, {
+      reporter: options.reporter || null,
+      logRecord: operation?._logRecord || null,
+    });
+    writeSourceSchemaMetadata(state.metadataPath, {
+      refreshedAt: new Date().toISOString(),
+      serviceName: config.name,
+      envName: state.envName,
+      cachePath: path.relative(config.productDir, state.cachePath),
+    });
+    const finished = operation
+      ? options.setupRegistry.finish(operation, {
+          status: "passed",
+          summary: `source schema refresh: ${path.relative(config.productDir, state.cachePath)}`,
+        })
+      : null;
+    if (finished) options.reporter?.setupOperationFinished?.(finished);
+  } catch (error) {
+    const finished = operation
+      ? options.setupRegistry.finish(operation, {
+          status: "failed",
+          summary: `source schema refresh: ${path.relative(config.productDir, state.cachePath)}`,
+          error: error?.message || error,
+        })
+      : null;
+    if (finished) options.reporter?.setupOperationFinished?.(finished);
+    throw error;
+  }
+}
+
+async function writeSourceSchemaCacheFromUrl(config, sourceUrl, cachePath, options = {}) {
+  fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+  const tempDir = fs.mkdtempSync(path.join(path.dirname(cachePath), ".source-schema-"));
+  const tempPath = path.join(tempDir, path.basename(cachePath));
+  try {
+    await dumpPostgresSchemaToFile(config, tempPath, sourceUrl, options);
+    fs.renameSync(tempPath, cachePath);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+function readSourceSchemaCacheText(cachePath) {
+  return sanitizeSnapshotText(fs.readFileSync(cachePath, "utf8"));
+}
+
+function shouldRefreshSourceSchema(state) {
+  if (!state.cacheExists) return true;
+  if (state.sourceSchema.refresh?.mode === "ttl") {
+    const meta = readJson(state.metadataPath);
+    const refreshedAt = meta?.refreshedAt ? Date.parse(meta.refreshedAt) : 0;
+    if (!Number.isFinite(refreshedAt) || refreshedAt <= 0) return true;
+    return Date.now() - refreshedAt >= state.sourceSchema.refresh.ttlSeconds * 1000;
+  }
+  return true;
+}
+
+function writeSourceSchemaMetadata(metadataPath, metadata) {
+  fs.mkdirSync(path.dirname(metadataPath), { recursive: true });
+  fs.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`);
+}
+
+function readJson(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function writeSchemaMismatchDiagnostics(config, sourceCachePath, sourceSchema, localSchema) {
+  const dir = path.join(config.productDir, ".testkit", "results", "schema");
+  fs.mkdirSync(dir, { recursive: true });
+  const prefix = `${sanitizePathSegment(config.runtimeLabel || config.name)}__${sanitizePathSegment(config.name)}`;
+  const sourcePath = path.join(dir, `${prefix}__source-schema.sql`);
+  const localPath = path.join(dir, `${prefix}__local-replay-schema.sql`);
+  const diffPath = path.join(dir, `${prefix}__schema.diff`);
+  fs.writeFileSync(sourcePath, sourceSchema);
+  fs.writeFileSync(localPath, localSchema);
+  fs.writeFileSync(diffPath, await buildUnifiedDiff(sourcePath, localPath));
+  return {
+    sourceCachePath,
+    sourcePath,
+    localPath,
+    diffPath,
+  };
+}
+
+async function buildUnifiedDiff(sourcePath, localPath) {
+  const result = await execa("diff", ["-u", sourcePath, localPath], {
+    reject: false,
+    stdout: "pipe",
+    stderr: "pipe",
+  }).catch((error) => ({ exitCode: 2, stdout: "", stderr: error.message }));
+  if (result.exitCode === 0 || result.exitCode === 1) return result.stdout || "";
+  return `Could not generate diff: ${result.stderr || "diff failed"}\n`;
+}
+
+function resolveUnavailableMode(value, env) {
+  if (value === "fail" || value === "warn-cache") return value;
+  return env.CI === "true" ? "fail" : "warn-cache";
+}
+
+function serviceSourceSchemaEnvName(serviceName) {
+  return `TESTKIT_${String(serviceName).toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_SCHEMA_SOURCE_DATABASE_URL`;
+}
+
+function sanitizePathSegment(value) {
+  return String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "schema";
+}

package/lib/database/template-steps.mjs

@@ -1,4 +1,5 @@
 import fs from "fs";
+import os from "os";
 import path from "path";
 import { execa } from "execa";
 import { buildTemplateExecutionEnv } from "../runner/template.mjs";
@@ -25,6 +26,25 @@ export async function runTemplateStage(config, stageName, databaseUrl, options =
     reporter: options.reporter || null,
     setupRegistry: options.setupRegistry || null,
     parentOperation: options.parentOperation || null,
+    afterStep: options.afterStep || null,
+  });
+}
+
+export async function runTemplateStep(config, stageName, step, stepIndex, databaseUrl, options = {}) {
+  const env = {
+    ...buildTemplateExecutionEnv(config, {}, process.env),
+    DATABASE_URL: databaseUrl,
+  };
+
+  await runConfiguredSteps({
+    config,
+    steps: [step],
+    env,
+    labelPrefix: `template:${stageName}`,
+    reporter: options.reporter || null,
+    setupRegistry: options.setupRegistry || null,
+    parentOperation: options.parentOperation || null,
+    startIndex: stepIndex,
   });
 }
 
@@ -36,45 +56,95 @@ export function collectTemplateInputs(productDir, template = {}) {
   });
 }
 
-export async function captureTemplateSnapshot(config, outputPath, databaseUrl, options = {}) {
-  const templateDbUrl = databaseUrl;
-  const absoluteOutputPath = path.resolve(config.productDir, outputPath);
-  fs.mkdirSync(path.dirname(absoluteOutputPath), { recursive: true });
+export async function captureTemplateSnapshotText(config, databaseUrl, options = {}) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-schema-snapshot-"));
+  const tempPath = path.join(tempDir, "schema.sql");
+  try {
+    await dumpPostgresSchemaToFile(config, tempPath, databaseUrl, options);
+    return fs.readFileSync(tempPath, "utf8");
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
 
-  const child = execa(
-    "pg_dump",
+export async function dumpPostgresSchemaToFile(config, outputPath, databaseUrl, options = {}) {
+  const env = {
+    ...buildTemplateExecutionEnv(config, {}, process.env),
+    ...buildPostgresConnectionEnv(databaseUrl),
+  };
+  const result = await runPgDumpCommand(config, "pg_dump", pgDumpArgs(), env, options);
+  if (result.exitCode !== 0 && isPgDumpServerVersionMismatch(result)) {
+    const serverMajor = parsePgDumpServerMajor(result);
+    if (serverMajor) {
+      const fallback = await runDockerizedPgDump(config, serverMajor, env, options);
+      if (fallback.exitCode === 0) {
+        fs.writeFileSync(outputPath, fallback.stdout);
+        sanitizeSnapshotFile(outputPath);
+        return;
+      }
+      throw new Error(fallback.shortMessage || fallback.stderr || fallback.stdout || "dockerized pg_dump failed");
+    }
+  }
+  if (result.exitCode !== 0) {
+    throw new Error(result.shortMessage || result.stderr || result.stdout || "pg_dump failed");
+  }
+  fs.writeFileSync(outputPath, result.stdout);
+  sanitizeSnapshotFile(outputPath);
+}
+
+function pgDumpArgs() {
+  return [
+    "--schema-only",
+    "--no-owner",
+    "--no-privileges",
+  ];
+}
+
+async function runDockerizedPgDump(config, serverMajor, env, options) {
+  const image = `${process.env.TESTKIT_PG_DUMP_IMAGE_PREFIX || "postgres"}:${serverMajor}`;
+  return runPgDumpCommand(
+    config,
+    "docker",
     [
-      "--schema-only",
-      "--no-owner",
-      "--no-privileges",
-      "--file",
-      absoluteOutputPath,
-      templateDbUrl,
+      "run",
+      "--rm",
+      "--network",
+      "host",
+      "-e",
+      "PGHOST",
+      "-e",
+      "PGPORT",
+      "-e",
+      "PGDATABASE",
+      "-e",
+      "PGUSER",
+      "-e",
+      "PGPASSWORD",
+      "-e",
+      "PGSSLMODE",
+      image,
+      "pg_dump",
+      ...pgDumpArgs(),
     ],
-    {
-      cwd: config.productDir,
-      env: {
-        ...buildTemplateExecutionEnv(config, {}, process.env),
-        DATABASE_URL: templateDbUrl,
-      },
-      stdout: "pipe",
-      stderr: "pipe",
-      reject: false,
-    }
+    env,
+    options
   );
+}
+
+async function runPgDumpCommand(config, command, args, env, options = {}) {
+  const child = execa(command, args, {
+    cwd: config.productDir,
+    env,
+    stdout: "pipe",
+    stderr: "pipe",
+    reject: false,
+  });
   const liveWriter =
     options.reporter?.outputMode === "debug"
       ? (line) => options.reporter.writeDebugLine?.(line)
       : null;
   const logRecord = options.logRecord || null;
   const drains = [
-    captureOutput(child.stdout, {
-      livePrefix: `[${config.runtimeLabel || config.name}:${config.name}]`,
-      liveWriter,
-      onLine(line) {
-        if (logRecord) logRecord.stream.write(`${new Date().toISOString()} [stdout] ${line}\n`);
-      },
-    }),
     captureOutput(child.stderr, {
       livePrefix: `[${config.runtimeLabel || config.name}:${config.name}]`,
       liveWriter,
@@ -85,29 +155,79 @@ export async function captureTemplateSnapshot(config, outputPath, databaseUrl, o
   ];
   const result = await child;
   await Promise.all(drains);
-  if (result.exitCode !== 0) {
-    throw new Error(result.shortMessage || result.stderr || result.stdout || "pg_dump failed");
-  }
+  return result;
+}
+
+function isPgDumpServerVersionMismatch(result) {
+  const text = `${result.stderr || ""}\n${result.stdout || ""}`;
+  return text.includes("server version mismatch");
+}
 
-  sanitizeSnapshotFile(absoluteOutputPath);
-  return absoluteOutputPath;
+function parsePgDumpServerMajor(result) {
+  const text = `${result.stderr || ""}\n${result.stdout || ""}`;
+  const match = text.match(/server version:\s*([0-9]+)/i);
+  return match ? Number(match[1]) : null;
+}
+
+function buildPostgresConnectionEnv(databaseUrl) {
+  const parsed = new URL(databaseUrl);
+  return compactObject({
+    PGHOST: parsed.hostname,
+    PGPORT: parsed.port || "5432",
+    PGDATABASE: decodeURIComponent(parsed.pathname.replace(/^\//, "")),
+    PGUSER: decodeURIComponent(parsed.username || ""),
+    PGPASSWORD: decodeURIComponent(parsed.password || ""),
+    PGSSLMODE: parsed.searchParams.get("sslmode") || undefined,
+  });
+}
+
+function compactObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([_key, entry]) => entry !== undefined && entry !== null && entry !== "")
+  );
 }
 
 export function sanitizeSnapshotFile(filePath) {
   const dump = fs.readFileSync(filePath, "utf8");
-  const sanitized = dump
-    .split("\n")
+  const sanitized = sanitizeSnapshotText(dump);
+
+  if (sanitized !== dump) {
+    fs.writeFileSync(filePath, sanitized);
+  }
+}
+
+export function sanitizeSnapshotText(dump) {
+  return removePublicSchemaInitdbBlock(String(dump).split("\n"))
     .filter((line) => {
       const trimmed = line.trim();
       return (
+        !trimmed.startsWith("-- Dumped from database version ") &&
+        !trimmed.startsWith("-- Dumped by pg_dump version ") &&
         trimmed !== "SET transaction_timeout = 0;" &&
         !trimmed.startsWith("\\restrict ") &&
         !trimmed.startsWith("\\unrestrict ")
       );
     })
     .join("\n");
+}
 
-  if (sanitized !== dump) {
-    fs.writeFileSync(filePath, sanitized);
+function removePublicSchemaInitdbBlock(lines) {
+  const normalized = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index]?.trim() === "--" && lines[index + 1]?.startsWith("-- Name: public; Type: SCHEMA;")) {
+      let cursor = index + 1;
+      while (cursor < lines.length && !lines[cursor]?.includes("*not* creating schema")) {
+        cursor += 1;
+      }
+      if (cursor < lines.length) {
+        while (cursor + 1 < lines.length && lines[cursor + 1]?.trim() === "") {
+          cursor += 1;
+        }
+        index = cursor;
+        continue;
+      }
+    }
+    normalized.push(lines[index]);
   }
+  return normalized;
 }

package/lib/runner/orchestrator.mjs

@@ -146,9 +146,10 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
         runtimeOptions: {
           reporter,
           logRegistry,
-          setupRegistry,
-        },
-      });
+        setupRegistry,
+        skipSchemaSourceVerify: opts.skipSchemaSourceVerify,
+      },
+    });
       const timingUpdates = [];
 
       try {

package/lib/runner/template-steps.mjs

@@ -51,13 +51,16 @@ export async function runConfiguredSteps({
   reporter = null,
   setupRegistry = null,
   parentOperation = null,
+  startIndex = 0,
+  afterStep = null,
 }) {
   if (steps.length === 0) return;
   const resolvedToolchain = await resolveConfiguredToolchain(config);
   await announceResolvedToolchain(config, resolvedToolchain, reporter);
 
   for (const [index, step] of steps.entries()) {
-    const label = `${labelPrefix}:${config.name}:${index + 1}`;
+    const stepNumber = startIndex + index + 1;
+    const label = `${labelPrefix}:${config.name}:${stepNumber}`;
     const stepOperation = setupRegistry?.start({
       config,
       stage: label,
@@ -89,6 +92,14 @@ export async function runConfiguredSteps({
       if (finished) reporter?.setupOperationFinished?.(finished);
       throw error;
     }
+    if (afterStep) {
+      await afterStep({
+        step,
+        index: startIndex + index,
+        stepNumber,
+        label,
+      });
+    }
   }
 }
 

package/lib/runner/template.mjs

@@ -1,5 +1,8 @@
 import path from "path";
-import { finalizeConfiguredInputs, finalizeConfiguredSteps } from "../shared/configured-steps.mjs";
+import {
+  finalizeConfiguredInputs,
+  finalizeConfiguredSteps,
+} from "../shared/configured-steps.mjs";
 import { readDatabaseInfo } from "./state-io.mjs";
 
 const PORT_STRIDE = 100;
@@ -135,6 +138,7 @@ export function resolveRuntimeConfig(
   const database = config.testkit.database
     ? {
         ...config.testkit.database,
+        sourceSchema: finalizeSourceSchema(config.testkit.database.sourceSchema, context),
         template: finalizeDatabaseTemplate(config.testkit.database.template, context),
       }
     : undefined;
@@ -193,6 +197,17 @@ function finalizeDatabaseTemplate(template, context) {
   };
 }
 
+function finalizeSourceSchema(sourceSchema, context) {
+  if (!sourceSchema) return null;
+  return {
+    ...sourceSchema,
+    ...(typeof sourceSchema.env === "string" ? { env: finalizeString(sourceSchema.env, context) } : {}),
+    ...(typeof sourceSchema.cachePath === "string"
+      ? { cachePath: finalizeString(sourceSchema.cachePath, context) }
+      : {}),
+  };
+}
+
 export function resolveServiceStateDir(runtimeDir, config) {
   return path.join(runtimeDir, "services", config.name);
 }

package/node_modules/@alcalzone/ansi-tokenize/README.md

@@ -231,11 +231,6 @@ This automatically figures out the least amount of escape codes necessary to ach
 	Placeholder for next release:
 	### __WORK IN PROGRESS__
 -->
-### 0.3.0 (2026-02-20)
-
--   Fix: preserve non-hyperlink OSC sequences when tokenizing (#54)
--   Fix: support ST-terminated OSC hyperlinks (#53)
-
 ### 0.2.5 (2026-02-11)
 
 -   Fix: preserve grapheme clusters when tokenizing (#51)

package/node_modules/@alcalzone/ansi-tokenize/build/ansiCodes.d.ts

@@ -1,5 +1,13 @@
 import type { AnsiCode } from "./tokenize.js";
+export declare const ESCAPES: Set<number>;
+export declare const CSI: number;
+export declare const OSC: number;
 export declare const endCodesSet: Set<string>;
+export declare const linkCodePrefix = "\u001B]8;";
+export declare const linkCodePrefixCharCodes: number[];
+export declare const linkCodeSuffix = "\u0007";
+export declare const linkCodeSuffixCharCode: number;
+export declare const linkEndCode: string;
 export declare function getLinkStartCode(url: string, params?: Record<string, string>): string;
 export declare function getEndCode(code: string): string;
 export declare function ansiCodesToString(codes: AnsiCode[]): string;

package/node_modules/@alcalzone/ansi-tokenize/build/ansiCodes.js

@@ -1,11 +1,18 @@
 import ansiStyles from "ansi-styles";
-import { linkCodePrefix, linkCodeSuffix, linkEndCode, linkEndCodeC1ST, linkEndCodeST, } from "./consts.js";
+export const ESCAPES = new Set([27, 155]); // \x1b and \x9b
+export const CSI = "[".codePointAt(0);
+export const OSC = "]".codePointAt(0);
 export const endCodesSet = new Set();
 const endCodesMap = new Map();
 for (const [start, end] of ansiStyles.codes) {
     endCodesSet.add(ansiStyles.color.ansi(end));
     endCodesMap.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
 }
+export const linkCodePrefix = "\x1B]8;"; // OSC 8 link prefix (params and URL follow)
+export const linkCodePrefixCharCodes = linkCodePrefix.split("").map((char) => char.charCodeAt(0));
+export const linkCodeSuffix = "\x07";
+export const linkCodeSuffixCharCode = linkCodeSuffix.charCodeAt(0);
+export const linkEndCode = `\x1B]8;;${linkCodeSuffix}`;
 export function getLinkStartCode(url, params) {
     const paramsStr = params
         ? Object.entries(params)
@@ -21,13 +28,8 @@ export function getEndCode(code) {
         return endCodesMap.get(code);
     // We have a few special cases to handle here:
     // Links:
-    if (code.startsWith(linkCodePrefix)) {
-        if (code.endsWith("\x1B\\"))
-            return linkEndCodeST;
-        if (code.endsWith("\x9C"))
-            return linkEndCodeC1ST;
-        return linkEndCode; // BEL (\x07)
-    }
+    if (code.startsWith(linkCodePrefix))
+        return linkEndCode;
     code = code.slice(2);
     // 8-bit/24-bit colors:
     if (code.startsWith("38")) {