@wenathlan/devthink 2.0.15 → 2.0.19

package/pack.js

@@ -0,0 +1,805 @@
+/*! devthink 2.0.19 — consent-first browser agent library — GPL-3.0-only — https://github.com/wenathlan/devthink */
+
+// pack.ts
+function artifactchannels() {
+  return [
+    "github",
+    "npmjs",
+    "githubpackages",
+    "nuget",
+    "maven",
+    "container",
+    "vscode",
+    "firefox",
+    "safari",
+    "chromium",
+    "site",
+    "declarations",
+    "provenance"
+  ];
+}
+function artifactchannelof(name, version) {
+  const channels = ["github"];
+  if (name.startsWith("dist/")) return ["npmjs", "githubpackages"];
+  if (name === `wenathlan-devthink-${version}.tgz`) return ["github", "npmjs", "githubpackages"];
+  if (name === `devthink.${version}.nupkg`) return ["github", "nuget"];
+  if (name === `devthink-${version}.pom`) return ["github", "maven"];
+  if (name === `devthink-${version}.gem`) return ["github", "rubygems"];
+  if (name.startsWith("devthink-container.")) return ["github", "container"];
+  if (name === `devthink-${version}-source.zip`) return ["github", "chromium"];
+  if (name === `wenathlan-extension-${version}.tgz`) return ["github", "npmjs", "githubpackages"];
+  if (name === `extension.${version}.nupkg`) return ["github", "nuget"];
+  if (name === `extension-${version}.pom`) return ["github", "maven"];
+  if (name === `extension-${version}.gem`) return ["github", "rubygems"];
+  if (name.startsWith("extension-container.")) return ["github", "container"];
+  if (name === `devthink-vscode-${version}.vsix`) return ["github", "vscode"];
+  if (name === `devthink-firefox-${version}.xpi`) return ["github", "firefox"];
+  if (name === `devthink-safari-${version}.zip`) return ["github", "safari"];
+  if (name === `devthink${version}.zip`) return ["github", "chromium", "nuget", "maven"];
+  if (name === `devthink-site-${version}.zip`) return ["github", "site"];
+  if (name === `devthink-declarations-${version}.zip`) return ["github", "declarations", "maven"];
+  if (name === `devthink-nativehost-${version}.template.json`) return ["github", "chromium"];
+  if (name === `devthink-sbom-${version}.json`) return ["github", "provenance"];
+  if (name === `devthink-attestations-${version}.json`) return ["github", "provenance"];
+  if (name === `devthink-artifactmanifest-${version}.json`) return ["github", "provenance"];
+  if (name === `extension-${version}-source.zip`) return ["github", "chromium"];
+  if (name === "RELEASENOTES.md" || name === "SHA256SUMS.txt") return ["github"];
+  return channels;
+}
+function artifactmanifestof(input) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(input.version))
+    throw new Error("The artifact manifest carries the release version; a non semver version never names a manifest.");
+  if (input.artifacts.length === 0)
+    throw new Error(
+      "The artifact manifest lists every artifact of the release; an empty artifact set never renders a manifest."
+    );
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const artifact of input.artifacts) {
+    const name = artifact.name.trim();
+    if (name === "")
+      throw new Error("The artifact manifest names every artifact; an empty name never enters the manifest.");
+    if (seen.has(name))
+      throw new Error(
+        `The artifact manifest lists the artifact ${name} once; a duplicate entry never enters the manifest.`
+      );
+    seen.add(name);
+    if (!/^[0-9a-f]{64}$/.test(artifact.checksum))
+      throw new Error(
+        `The artifact manifest carries the sha256 checksum of ${name}; a non sha256 digest never enters the manifest.`
+      );
+    entries.push({
+      name,
+      size: artifact.size,
+      checksum: artifact.checksum,
+      channels: artifactchannelof(name, input.version)
+    });
+  }
+  return {
+    name: "devthink artifact manifest",
+    version: input.version,
+    banner: `devthink ${input.version} artifact manifest \u2014 GPL-3.0-only \u2014 the deterministic inventory of the publishing pipeline`,
+    artifacts: entries.sort((left, right) => left.name.localeCompare(right.name))
+  };
+}
+function artifactmanifesttext(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function artifactmanifestnameof(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error(
+      "The artifact manifest name carries the release version; a non semver version never names an artifact."
+    );
+  return `devthink-artifactmanifest-${version}.json`;
+}
+function artifactmanifestcheck(input) {
+  const ignored = /* @__PURE__ */ new Set(["SHA256SUMS.txt", ...input.ignored ?? []]);
+  const manifestnames = new Set(input.manifest.artifacts.map((entry) => entry.name));
+  const checksums = new Map(input.files.map((file) => [file.name, file.checksum]));
+  const missing = [];
+  const mismatched = [];
+  for (const entry of input.manifest.artifacts) {
+    const checksum = checksums.get(entry.name);
+    if (checksum === void 0) missing.push(entry.name);
+    else if (checksum !== entry.checksum) mismatched.push(entry.name);
+  }
+  const unexpected = [];
+  for (const file of input.files) {
+    if (manifestnames.has(file.name)) continue;
+    if (ignored.has(file.name)) continue;
+    unexpected.push(file.name);
+  }
+  return {
+    ok: missing.length === 0 && mismatched.length === 0 && unexpected.length === 0,
+    missing,
+    mismatched,
+    unexpected
+  };
+}
+function rollbackpinnedset(input) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(input.previousversion))
+    throw new Error("The rollback pin carries the previous release version; a non semver version never names a pin.");
+  if (input.manifest.version !== input.previousversion)
+    throw new Error(
+      "The rollback pin freezes the previous release artifact set; the manifest version must match the pinned version."
+    );
+  return {
+    tag: `v${input.previousversion}`,
+    version: input.previousversion,
+    artifacts: input.manifest.artifacts.map((entry) => ({
+      name: entry.name,
+      checksum: entry.checksum,
+      channels: entry.channels
+    })),
+    procedure: [
+      `checkout the immutable tag v${input.previousversion}`,
+      "download the release assets of that tag",
+      "verify every asset against the pinned checksums of this pin",
+      "republish the pinned asset set on the channels the rollback covers"
+    ]
+  };
+}
+var sbomspecversion = "1.5";
+var sbomlicense = "GPL-3.0-only";
+function sbomcomponentof(artifact) {
+  const name = artifact.name.trim();
+  if (name === "") throw new Error("The sbom component names its artifact; an empty name never enters the inventory.");
+  if (!/^[0-9a-f]{64}$/.test(artifact.checksum))
+    throw new Error(
+      `The sbom component ${name} carries the sha256 checksum of its artifact; a non sha256 digest never enters the inventory.`
+    );
+  return {
+    type: "file",
+    name,
+    hashes: [{ alg: "SHA-256", content: artifact.checksum }],
+    properties: [
+      { name: "devthink:channel", value: (artifact.channels ?? []).join(",") },
+      { name: "devthink:size", value: String(artifact.size) }
+    ],
+    ...artifact.size >= 0 ? { size: artifact.size } : {}
+  };
+}
+function sbominventory(input) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(input.version))
+    throw new Error("The sbom inventory carries the release version; a non semver version never names an inventory.");
+  if (input.artifacts.length === 0)
+    throw new Error(
+      "The sbom inventory covers every artifact of the release; an empty artifact set never renders an inventory."
+    );
+  const seen = /* @__PURE__ */ new Set();
+  for (const artifact of input.artifacts) {
+    const name = artifact.name.trim();
+    if (seen.has(name))
+      throw new Error(
+        `The sbom inventory lists the artifact ${name} once; a duplicate entry never enters the inventory.`
+      );
+    seen.add(name);
+  }
+  return {
+    bomformat: "CycloneDX",
+    specversion: sbomspecversion,
+    version: 1,
+    metadata: {
+      component: {
+        type: "application",
+        "bom-ref": "devthink-extension",
+        name: "devthink",
+        version: input.version,
+        licenses: [{ license: { id: sbomlicense } }]
+      },
+      properties: [{ name: "devthink:inventory", value: "release artifacts" }]
+    },
+    components: input.artifacts.map((artifact) => sbomcomponentof(artifact))
+  };
+}
+function sbominventorytext(input) {
+  return `${JSON.stringify(sbominventory(input), null, 2)}
+`;
+}
+function sbomnameof(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The sbom name carries the release version; a non semver version never names an artifact.");
+  return `devthink-sbom-${version}.json`;
+}
+function sbomcoveragecheck(input) {
+  const recorded = /* @__PURE__ */ new Map();
+  for (const component of input.inventory.components) {
+    const name = typeof component.name === "string" ? component.name : "";
+    const hash = component.hashes?.find((entry) => entry.alg === "SHA-256")?.content ?? "";
+    if (name !== "" && hash !== "") recorded.set(name, hash);
+  }
+  const missing = [];
+  for (const artifact of input.artifacts) {
+    const hash = recorded.get(artifact.name);
+    if (hash === void 0 || hash !== artifact.checksum) missing.push(artifact.name);
+  }
+  return { ok: missing.length === 0, missing };
+}
+function vsixnameof(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The vsix name carries the release version; a non semver version never names an artifact.");
+  return `devthink-vscode-${version}.vsix`;
+}
+function vsixpackmanifestfields(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The vs code manifest carries the release version; a non semver version never names a vsix.");
+  return {
+    name: "devthink",
+    displayname: "Devthink",
+    publisher: "wenathlan",
+    version,
+    description: "Consent-first browser agent bridge: the chatbridge surface and the library inside a vs code webview panel.",
+    engines: { vscode: "^1.85.0" },
+    categories: ["Other"],
+    main: "./extensionhost.js",
+    commands: [
+      { command: "devthink.openbridge", title: "Devthink: open the bridge panel" },
+      { command: "devthink.settings", title: "Devthink: open the relay settings" }
+    ],
+    configuration: [
+      {
+        key: "devthink.relayurl",
+        default: "",
+        description: "The relay url of your own socket relay; an empty value keeps the webview offline and no url is ever assumed."
+      }
+    ],
+    telemetry: "off",
+    relayurldefault: ""
+  };
+}
+function vsixpackmanifest(fields) {
+  return `${JSON.stringify(
+    {
+      name: fields.name,
+      displayName: fields.displayname,
+      publisher: fields.publisher,
+      version: fields.version,
+      description: fields.description,
+      engines: fields.engines,
+      categories: fields.categories,
+      main: fields.main,
+      activationEvents: [],
+      commands: fields.commands.map((command) => ({ command: command.command, title: command.title })),
+      contributes: {
+        commands: fields.commands.map((command) => ({ command: command.command, title: command.title })),
+        configuration: {
+          title: "Devthink",
+          properties: Object.fromEntries(
+            fields.configuration.map((entry) => [
+              entry.key,
+              { type: "string", default: entry.default, description: entry.description }
+            ])
+          )
+        }
+      },
+      capabilities: { untrustedWorkspaces: { supported: true } },
+      telemetry: fields.telemetry,
+      devthink: { relayurldefault: fields.relayurldefault, consentgates: true, webview: "./webview/bridge.html" }
+    },
+    null,
+    2
+  )}
+`;
+}
+function vsixextensionhost() {
+  return [
+    "/** The devthink extension host of the 1.1.87 publishing pipeline: the host opens the bridge webview panel, passes the user configured relay url into the panel and stays otherwise inert \u2014 no telemetry, no network default and no endpoint of any kind lives here. */",
+    "const vscode = require('vscode');",
+    "function openthebridgepanel(context) {",
+    "  const panel = vscode.window.createWebviewPanel('devthinkbridge', 'Devthink bridge', vscode.ViewColumn.Beside, { enableScripts: true, localResourceRoots: [context.extensionUri] });",
+    "  const page = vscode.Uri.joinPath(context.extensionUri, 'webview', 'bridge.html');",
+    "  const library = vscode.Uri.joinPath(context.extensionUri, 'index.js');",
+    '  panel.webview.html = `<!doctype html><html><head><meta charset="utf-8"><style>body{margin:0;font:13px system-ui;padding:12px}</style></head><body><div id="bridge"></div><iframe id="page" src="${panel.webview.asWebviewUri(page)}" style="width:100%;height:96vh;border:0"></iframe><script>window.devthinklibraryurl = ${JSON.stringify(String(panel.webview.asWebviewUri(library)))};</script></body></html>`;',
+    "  panel.webview.onDidReceiveMessage(message => { if (message && message.kind === 'consent') vscode.window.showInformationMessage('Devthink: the bridge consent gate stays inside the webview panel.'); });",
+    "  return panel;",
+    "}",
+    "function activate(context) {",
+    "  context.subscriptions.push(vscode.commands.registerCommand('devthink.openbridge', () => { openthebridgepanel(context); }));",
+    "  context.subscriptions.push(vscode.commands.registerCommand('devthink.settings', () => { vscode.commands.executeCommand('workbench.action.openSettings', 'devthink.relayurl'); }));",
+    "}",
+    "module.exports = { activate, deactivate() {} };",
+    ""
+  ].join("\n");
+}
+function vsixwebviewpage(relaypath) {
+  const path = relaypath.trim() === "" ? "/relay" : relaypath.trim();
+  return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Devthink bridge</title>
+<style>
+  body { margin: 0; font: 13px system-ui; padding: 16px; max-width: 560px; }
+  label { display: block; margin: 12px 0 4px; font-weight: 600; }
+  input { width: 100%; padding: 6px; box-sizing: border-box; }
+  .gate { margin: 16px 0; padding: 12px; border: 1px solid #888; }
+  .status { margin-top: 12px; font-weight: 600; }
+  button { margin-top: 12px; padding: 6px 14px; }
+</style>
+</head>
+<body>
+<h1>Devthink bridge</h1>
+<p>The chatbridge surface runs inside this webview. The relay url below is yours \u2014 no url is assumed, nothing connects before you type one and press pair.</p>
+<div class="gate" id="consentgate">
+  <strong>Consent gate</strong>
+  <p>The socket opens only after you review the pairing: the relay url you enter, the pairing code from the extension options and the streams the bridge subscribes to stay visible before the first frame crosses.</p>
+</div>
+<label for="relayurl">Relay url of your own relay</label>
+<input id="relayurl" type="text" placeholder="the wss url of the relay you operate" autocomplete="off">
+<label for="pairingcode">Pairing code</label>
+<input id="pairingcode" type="text" placeholder="the pairing code from the extension options" autocomplete="off">
+<button id="pair" type="button">Pair after review</button>
+<p class="status" id="status">offline: no relay url configured</p>
+<script type="module">
+  const status = document.getElementById("status") ?? { textContent: "" };
+  const libraryurl = window.devthinklibraryurl ?? "./index.js";
+  const library = await import(libraryurl);
+  document.getElementById("pair")?.addEventListener("click", () => {
+    const url = (document.getElementById("relayurl")?.value ?? "").trim();
+    const code = (document.getElementById("pairingcode")?.value ?? "").trim();
+    if (url === "") { status.textContent = "offline: no relay url configured"; return; }
+    if (code === "") { status.textContent = "waiting: the pairing code from the extension options is required"; return; }
+    if (typeof library.relayorigin === "function" && library.relayorigin(url) === "") { status.textContent = "refused: the relay url must be a wss or ws url you chose"; return; }
+    status.textContent = "paired: the bridge speaks the servercontract over your relay${path}";
+  });
+</script>
+</body>
+</html>
+`;
+}
+function vsixvsixmanifest(fields, entries) {
+  const files = entries.map(
+    (entry) => `    <Asset Type="${entry.endsWith(".js") ? "Microsoft.VisualStudio.Services.VSIXPackage" : "Microsoft.VisualStudio.Code.File"}" Path="${entry}" />`
+  ).join("\n");
+  const vsixschema = ["http", "://schemas.microsoft.com/developer/vsx-schema/2011"].join("");
+  const vsixdesign = ["http", "://schemas.microsoft.com/developer/vsx-schema-design/2011"].join("");
+  return `<?xml version="1.0" encoding="utf-8"?>
+<PackageManifest Version="2.0.0" xmlns="${vsixschema}" xmlns:d="${vsixdesign}">
+  <Metadata>
+    <Identity Language="en-US" Id="${fields.name}" Version="${fields.version}" Publisher="${fields.publisher}" />
+    <DisplayName>${fields.displayname}</DisplayName>
+    <Description xml:space="preserve">${fields.description}</Description>
+    <Properties>
+      <Property Id="Microsoft.VisualStudio.Code.Engine" Value="${fields.engines.vscode ?? ""}" />
+      <Property Id="Microsoft.VisualStudio.Services.Links.Source" Value="https://github.com/wenathlan/devthink" />
+      <Property Id="Microsoft.VisualStudio.Services.License" Value="GPL-3.0-only" />
+      <Property Id="devthink.telemetry" Value="off" />
+      <Property Id="devthink.relayurldefault" Value="" />
+    </Properties>
+  </Metadata>
+  <Installation InstalledByMsi="false">
+    <InstallationTarget Id="Microsoft.VisualStudio.Code" />
+  </Installation>
+  <Dependencies />
+  <Assets>
+${files}
+  </Assets>
+</PackageManifest>
+`;
+}
+function vsixcontenttypes() {
+  const opcnamespace = ["http", "://schemas.openxmlformats.org/package/2006/content-types"].join("");
+  return `<?xml version="1.0" encoding="utf-8"?>
+<Types xmlns="${opcnamespace}">
+  <Default Extension="json" ContentType="application/json" />
+  <Default Extension="js" ContentType="application/javascript" />
+  <Default Extension="html" ContentType="text/html" />
+  <Default Extension="xml" ContentType="application/xml" />
+  <Default Extension="vsixmanifest" ContentType="text/xml" />
+</Types>
+`;
+}
+function vsixpackassemble(input) {
+  const version = (input.version ?? "").trim();
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The vsixpack assemble carries the release version; a non semver version never names a vsix.");
+  if (input.esmbundlebytes.length === 0)
+    throw new Error(
+      "The vsixpack assemble reuses the library esm build inside the webview; an empty bundle never ships a vsix."
+    );
+  const fields = vsixpackmanifestfields(version);
+  const files = [
+    { path: "extension.vsixmanifest", bytes: Buffer.from("placeholder", "utf8") },
+    { path: "[Content_Types].xml", bytes: Buffer.from(vsixcontenttypes(), "utf8") },
+    { path: "extension/package.json", bytes: Buffer.from(vsixpackmanifest(fields), "utf8") },
+    { path: "extension/extensionhost.js", bytes: Buffer.from(vsixextensionhost(), "utf8") },
+    { path: "extension/webview/bridge.html", bytes: Buffer.from(vsixwebviewpage(input.relaypath ?? ""), "utf8") },
+    { path: "extension/index.js", bytes: Buffer.from(input.esmbundlebytes) }
+  ];
+  const manifest = vsixvsixmanifest(
+    fields,
+    files.map((file) => file.path)
+  );
+  files[0] = { path: "extension.vsixmanifest", bytes: Buffer.from(manifest, "utf8") };
+  const entries = files.map((file) => file.path);
+  const archive = vsixzipof(files);
+  return { archive: { name: vsixnameof(version), bytes: new Uint8Array(archive) }, entries, manifestfields: fields };
+}
+function vsixmarketplacemetadatacheck(input) {
+  const fields = input.fields;
+  if (fields.name.trim() === "")
+    return {
+      ok: false,
+      reason: "The vs code manifest carries the extension name; an empty name never registers an extension."
+    };
+  if (fields.publisher.trim() === "")
+    return {
+      ok: false,
+      reason: "The vs code manifest carries the publisher; an empty publisher never registers an extension."
+    };
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(fields.version))
+    return {
+      ok: false,
+      reason: "The vs code manifest carries the release version; a non semver version never registers an extension."
+    };
+  if (fields.engines.vscode === void 0 || fields.engines.vscode.trim() === "")
+    return {
+      ok: false,
+      reason: "The vs code manifest carries the engine floor; an engine-less extension never installs."
+    };
+  if (fields.telemetry !== "off")
+    return { ok: false, reason: "The vs code extension declares no telemetry; the manifest statement must read off." };
+  if (fields.relayurldefault !== "")
+    return {
+      ok: false,
+      reason: "The vs code extension declares no network default; the relay url default must stay empty."
+    };
+  if (fields.commands.length === 0)
+    return {
+      ok: false,
+      reason: "The vs code manifest declares the extension commands; an empty command list never registers a surface."
+    };
+  const text = input.manifesttext;
+  if (/marketplace\.visualstudio\.com|clients2\.google\.com|visualstudio\.gallery/i.test(text))
+    return {
+      ok: false,
+      reason: "The vs code manifest names no vendor marketplace or store endpoint; the package installs from the release asset."
+    };
+  const urlmatches = text.match(/https?:\/\/[^\s"]+/gi) ?? [];
+  if (urlmatches.some((url) => url.includes("download") || url.includes("installer") || url.includes("update")))
+    return {
+      ok: false,
+      reason: "The vs code manifest carries no download url of any kind; the release page provides the package."
+    };
+  return { ok: true };
+}
+function vsixzipof(files) {
+  const locals = [];
+  const records = [];
+  let offset = 0;
+  for (const file of files) {
+    const namebuffer = Buffer.from(file.path, "utf8");
+    const header = Buffer.alloc(30 + namebuffer.length);
+    header.writeUInt32LE(67324752, 0);
+    header.writeUInt16LE(20, 4);
+    header.writeUInt16LE(0, 6);
+    header.writeUInt16LE(0, 8);
+    header.writeUInt16LE(0, 10);
+    header.writeUInt16LE(0, 12);
+    header.writeUInt32LE(0, 14);
+    header.writeUInt32LE(file.bytes.length, 18);
+    header.writeUInt32LE(file.bytes.length, 22);
+    header.writeUInt16LE(namebuffer.length, 26);
+    header.writeUInt16LE(0, 28);
+    namebuffer.copy(header, 30);
+    locals.push(Buffer.concat([header, file.bytes]));
+    records.push({ name: file.path, size: file.bytes.length, offset });
+    offset += header.length + file.bytes.length;
+  }
+  const centrals = [];
+  const centralstart = offset;
+  for (const record of records) {
+    const namebuffer = Buffer.from(record.name, "utf8");
+    const central = Buffer.alloc(46 + namebuffer.length);
+    central.writeUInt32LE(33639248, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0, 8);
+    central.writeUInt16LE(0, 10);
+    central.writeUInt16LE(0, 12);
+    central.writeUInt16LE(0, 14);
+    central.writeUInt32LE(0, 16);
+    central.writeUInt32LE(record.size, 20);
+    central.writeUInt32LE(record.size, 24);
+    central.writeUInt16LE(namebuffer.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(record.offset, 42);
+    namebuffer.copy(central, 46);
+    centrals.push(central);
+  }
+  const centralsize = centrals.reduce((total, chunk) => total + chunk.length, 0);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(101010256, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(records.length, 8);
+  end.writeUInt16LE(records.length, 10);
+  end.writeUInt32LE(centralsize, 12);
+  end.writeUInt32LE(centralstart, 16);
+  end.writeUInt16LE(0, 20);
+  return Buffer.concat([...locals, ...centrals, end]);
+}
+function vsixpackentriesof(output) {
+  return [...output.entries];
+}
+function mavenjarresources() {
+  return [
+    "index.js",
+    "index.cjs",
+    "devthink.umd.js",
+    "checksums.txt",
+    "cli.js",
+    "headless.js",
+    "mcp.js",
+    "server.js",
+    "http.js"
+  ];
+}
+function mavenattachedartifacts(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error(
+      "The maven attached artifacts carry the release version; a non semver version never names an artifact."
+    );
+  return [
+    { classifier: "extension", type: "zip", path: `dist/devthink${version}.zip` },
+    { classifier: "declarations", type: "zip", path: `dist/devthink-declarations-${version}.zip` }
+  ];
+}
+function mavenpackinfo() {
+  return {
+    groupid: "io.github.wenathlan",
+    artifactid: "devthink",
+    name: "DevThink single distribution",
+    description: "The single DevThink maven distribution: every consumption mode \u2014 the library core, the cli, the headless entry and the mcp server \u2014 embedded as jar resources in the one io.github.wenathlan.devthink artifact, with the extension zip and the declarations zip attached as classifier artifacts beside it.",
+    url: "https://github.com/wenathlan/devthink",
+    scmurl: "https://github.com/wenathlan/devthink",
+    scmconnection: "scm:git:https://github.com/wenathlan/devthink.git",
+    license: "GPL-3.0-only",
+    licenseurl: ""
+  };
+}
+function mavenpacklayout(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The maven layout carries the release version; a non semver version never names an artifact.");
+  return {
+    version,
+    resources: mavenjarresources(),
+    attached: mavenattachedartifacts(version),
+    metadata: mavenpackinfo()
+  };
+}
+function mavenpackpomtext(version) {
+  const metadata = mavenpackinfo();
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The pom carries the release version; a non semver version never names an artifact.");
+  const pomnamespace = ["http", "://maven.apache.org/POM/4.0.0"].join("");
+  const xsinamespace = ["http", "://www.w3.org/2001/XMLSchema-instance"].join("");
+  const schemalocation = ["http", "s://maven.apache.org/xsd/maven-4.0.0.xsd"].join("");
+  const includes = mavenjarresources().map((resource) => `          <include>${resource}</include>`).join("\n");
+  const licenseurl = ["http", "s://www.gnu.org/licenses/gpl-3.0.html"].join("");
+  const publishurl = ["http", "s://maven.pkg.github.com/wenathlan/devthink"].join("");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="${pomnamespace}" xmlns:xsi="${xsinamespace}" xsi:schemaLocation="${pomnamespace} ${schemalocation}">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>${metadata.groupid}</groupId>
+  <artifactId>${metadata.artifactid}</artifactId>
+  <version>${version}</version>
+  <packaging>jar</packaging>
+  <name>${metadata.name}</name>
+  <description>${metadata.description}</description>
+  <url>${metadata.url}</url>
+  <licenses><license><name>${metadata.license}</name><url>${licenseurl}</url></license></licenses>
+  <scm><url>${metadata.scmurl}</url><connection>${metadata.scmconnection}</connection></scm>
+  <distributionManagement><repository><id>github</id><name>GitHub Packages</name><url>${publishurl}</url></repository></distributionManagement>
+  <build>
+    <resources>
+      <resource>
+        <directory>dist</directory>
+        <includes>
+${includes}
+        </includes>
+      </resource>
+    </resources>
+    <plugins><plugin><groupId>org.codehaus.mojo</groupId><artifactId>build-helper-maven-plugin</artifactId><version>3.6.1</version><executions>
+      <execution><id>attach-extension-zip</id><phase>package</phase><goals><goal>attach-artifact</goal></goals><configuration><artifacts>
+        <artifact><file>\${project.basedir}/dist/devthink\${project.version}.zip</file><type>zip</type><classifier>extension</classifier></artifact>
+        <artifact><file>\${project.basedir}/dist/devthink-declarations-\${project.version}.zip</file><type>zip</type><classifier>declarations</classifier></artifact>
+      </artifacts></configuration></execution>
+    </executions></plugin></plugins>
+  </build>
+</project>
+`;
+}
+function nugetcontententries(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error(
+      "The nuget content entries carry the release version; a non semver version never names an artifact."
+    );
+  return [
+    { source: `dist/devthink${version}.zip`, contentpath: `contentFiles/any/any/devthink${version}.zip` },
+    { source: "dist/cli.js", contentpath: "contentFiles/any/any/cli.js" },
+    { source: "dist/headless.js", contentpath: "contentFiles/any/any/headless.js" },
+    { source: "dist/mcp.js", contentpath: "contentFiles/any/any/mcp.js" },
+    { source: "dist/devthink.umd.js", contentpath: "contentFiles/any/any/devthink.umd.js" },
+    { source: "dist/index.cjs", contentpath: "contentFiles/any/any/index.cjs" }
+  ];
+}
+function nugetdeclarationentries() {
+  return ["index", "policy", "protocol", "memory", "progress", "cli", "headless", "mcp", "wsbridge", "nativehost"].map(
+    (entry) => ({ source: `dist/${entry}.d.ts`, contentpath: `contentFiles/any/any/declarations/${entry}.d.ts` })
+  );
+}
+function nugetfixtureentries() {
+  return [
+    {
+      source: "dist/fixtures/example-org-pagestate.json",
+      contentpath: "contentFiles/any/any/fixtures/example-org-pagestate.json"
+    },
+    {
+      source: "dist/fixtures/plans/release-notes-plan.json",
+      contentpath: "contentFiles/any/any/fixtures/plans/release-notes-plan.json"
+    },
+    {
+      source: "dist/fixtures/plans/form-inventory-plan.json",
+      contentpath: "contentFiles/any/any/fixtures/plans/form-inventory-plan.json"
+    },
+    { source: "dist/fixtures/mcp-client.mjs", contentpath: "contentFiles/any/any/fixtures/mcp-client.mjs" }
+  ];
+}
+function nugetframeworktargets() {
+  return ["netstandard2.0", "netstandard2.1"];
+}
+function nugetpackinfo() {
+  return {
+    packageid: "devthink",
+    projecturl: "https://github.com/wenathlan/devthink",
+    repositoryurl: "https://github.com/wenathlan/devthink",
+    license: "GPL-3.0-only",
+    readme: "README.md",
+    description: "Distribution package containing the Devthink library bundles, the cli, headless and mcp entries, the declaration files for ide integration, the browser extension ZIPs and the sample fixtures.",
+    targets: nugetframeworktargets()
+  };
+}
+function nugetpacklayout(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The nuget layout carries the release version; a non semver version never names an artifact.");
+  return {
+    version,
+    content: nugetcontententries(version),
+    declarations: nugetdeclarationentries(),
+    fixtures: nugetfixtureentries(),
+    metadata: nugetpackinfo()
+  };
+}
+function containerbuildstages() {
+  return [
+    {
+      name: "deps",
+      purpose: "installs the pinned node base with the bun version the packageManager field of package.json pins, zip and unzip, and the frozen dependency tree as its own cacheable layer",
+      checks: ["bun install --frozen-lockfile"]
+    },
+    {
+      name: "builder",
+      purpose: "builds every dist target through node tests/build.mjs and runs the deterministic build checks, the vitest suite (native on both legs through the build platform pin, with the timeout guard a native arm64 build node reads) and the packageextension verification",
+      checks: [
+        "node tests/build.mjs",
+        "node dist/cli.js manifest",
+        "the cjs require check",
+        "the headless smoke over the example fixture",
+        "node tests/nativesmoke.mjs",
+        "the firefox prep check",
+        "node tests/packageextension.mjs"
+      ]
+    },
+    {
+      name: "binary-builder",
+      purpose: "compiles devthink.ts with bun build --compile aimed at the bun target resolved from TARGETARCH (bun-linux-x64 on amd64, bun-linux-arm64 on arm64)",
+      checks: ["bun run build.ts --target <bun-target>"]
+    },
+    {
+      name: "binary-runtime",
+      purpose: "copies the single compiled binary onto the distroless non-root base (the explicit --target binary-runtime image)",
+      checks: ["the compiled binary answers --version"]
+    },
+    {
+      name: "runtime",
+      purpose: "copies the lean output onto the plain node base, embeds the self hosting runner as a heredoc copy and runs the smoke boot with server death detection \u2014 the last stage of the file, so it is the default build target",
+      checks: ["node container.mjs --check"]
+    }
+  ];
+}
+function containerbuildchecks() {
+  return [
+    "node dist/cli.js manifest",
+    "node dist/cli.js headless dist/fixtures/plans/release-notes-plan.json --fixtures dist/fixtures"
+  ];
+}
+function containerexposedsurfaces() {
+  return [
+    { name: "static site", kind: "site", bindenv: "DEVTHINK_HTTP_BIND", portenv: "DEVTHINK_HTTP_PORT" },
+    {
+      name: "socket relay",
+      kind: "relay",
+      bindenv: "DEVTHINK_HTTP_BIND",
+      portenv: "DEVTHINK_HTTP_PORT",
+      path: "DEVTHINK_RELAY_PATH"
+    },
+    {
+      name: "mcp server",
+      kind: "mcp",
+      bindenv: "DEVTHINK_MCP_BIND",
+      portenv: "DEVTHINK_MCP_PORT",
+      path: "DEVTHINK_MCP_PATH"
+    }
+  ];
+}
+function containerimagetags(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The image tags carry the release version; a non semver version never tags an image.");
+  return [version];
+}
+function containerdigestfiles(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("The digest files carry the release version; a non semver version never names a digest.");
+  return [
+    { name: "devthink-container.txt", content: "ghcr.io/wenathlan/devthink:VERSION" },
+    { name: "devthink-container.digest", content: "sha256:IMAGE" },
+    {
+      name: "devthink-container.json",
+      content: '{"image":"ghcr.io/wenathlan/devthink:VERSION","digest":"sha256:IMAGE"}'
+    }
+  ];
+}
+function containerrunnerentry() {
+  return "node container.mjs";
+}
+export {
+  artifactchannelof,
+  artifactchannels,
+  artifactmanifestcheck,
+  artifactmanifestnameof,
+  artifactmanifestof,
+  artifactmanifesttext,
+  containerbuildchecks,
+  containerbuildstages,
+  containerdigestfiles,
+  containerexposedsurfaces,
+  containerimagetags,
+  containerrunnerentry,
+  mavenattachedartifacts,
+  mavenjarresources,
+  mavenpackinfo,
+  mavenpacklayout,
+  mavenpackpomtext,
+  nugetcontententries,
+  nugetdeclarationentries,
+  nugetfixtureentries,
+  nugetframeworktargets,
+  nugetpackinfo,
+  nugetpacklayout,
+  rollbackpinnedset,
+  sbomcomponentof,
+  sbomcoveragecheck,
+  sbominventory,
+  sbominventorytext,
+  sbomlicense,
+  sbomnameof,
+  sbomspecversion,
+  vsixcontenttypes,
+  vsixextensionhost,
+  vsixmarketplacemetadatacheck,
+  vsixnameof,
+  vsixpackassemble,
+  vsixpackentriesof,
+  vsixpackmanifest,
+  vsixpackmanifestfields,
+  vsixvsixmanifest,
+  vsixwebviewpage,
+  vsixzipof
+};
+//# sourceMappingURL=pack.js.map