@sema-agent/settings-schema 10.1.1 → 11.1.0

package/dist/secret-scan.js

@@ -1,17 +1,18 @@
 /**
  * 秘密扫描读的**归一化**,外加「URL 的 userinfo 就是凭据」那一只判定({@link carriesUserinfo})—— 包内私有模块(6.3.0):不进主 barrel、
  * 不进 `package.json` 的 `exports`,消费方拿不到。
- * 校验侧探测器 `containsSecretToken`(`./types`)只读 {@link percentLayers};展示侧脱敏器 `redactSecrets`(`./config-fns`)
- * 读 {@link secretScanForms}。展示侧的读法(边界读法、`+` 读法、「没走完」那一位)刻意不做公开契约:它们以后要随新发现的
- * 编码形调整,调整不该是契约变更(opus 独立腿 L7)。
+ * 校验侧探测器 `containsSecretToken`(`./types`)与展示侧脱敏器 `redactSecrets`(`./config-fns`)读**同一组**形 {@link secretScanForms}
+ * (11.0.0 起一只扫描器,S-1274;改前校验侧只读百分号层)。这组读法(边界读法、`+` 读法、「没走完」那一位)刻意不做公开契约:
+ * 它们以后要随新发现的编码形调整,调整不该是契约变更(opus 独立腿 L7)—— 但写与显永远同时调整。
  *
  * **单遍、零异常**(opus 独立腿 M1,对 6.2.0 的读路径 CPU 回归):6.2.0 起的宽容解码对每个 `%HH` 各 `try decodeURIComponent`,
  * 非 ASCII 的转义每个都抛一次异常(≈ 20–30 µs / 字节,同步阻塞);6.3.0 首稿又让探测器顺带算它不用的展示形。这里两处解码都
  * 不靠异常:单个转义的判据写成字符集(只有 ASCII 的 `%00`–`%7F` 单独解得开),转义串的判据写成 UTF-8 良构判定 ——
  * 结果与原来的 try/catch 逐字相同(`test/disclosable-identity-6.3.0.test.ts` 的两只冻结 oracle 钉着)。
  *
- * 本模块零 import(`./types` 引它,它不回引,不成环)。
+ * 本模块只引 `./url-shape`(零 import 的叶子;`./types` 引本模块,本模块不回引,不成环)。
  */
+import { httpUrlFlaws } from "./url-shape.js"; // the URL shape judge — whether a parsed URL carries userinfo is its call
 /** How many percent-decoded layers a secret scan reads beyond the raw string (a multi-encoded `%2573%256B…` →
  *  `%73%6B…` → `sk-…`). Bounded → deterministic. */
 export const SECRET_SCAN_DECODE_LAYERS = 3;
@@ -23,8 +24,8 @@ function percentDecodeLayer(s) {
     return s.indexOf("%") === -1 ? s : s.replace(/%([0-7][0-9A-Fa-f])/g, (_m, hex) => String.fromCharCode(parseInt(hex, 16)));
 }
 /** The raw string first, then up to {@link SECRET_SCAN_DECODE_LAYERS} tolerant percent-decoded layers, stopping at the first
- *  layer that decodes nothing — the forms the validation detector `containsSecretToken` reads, and nothing else. */
-export function percentLayers(text) {
+ *  layer that decodes nothing — the first part of {@link secretScanForms}. */
+function percentLayers(text) {
     const layers = [text];
     let cur = text;
     for (let i = 0; i < SECRET_SCAN_DECODE_LAYERS; i++) {
@@ -70,7 +71,7 @@ function isWellFormedUtf8(bytes) {
  *  is well-formed (an encoded NBSP / zero-width space becomes the delimiter it really is); otherwise its ASCII escapes decode
  *  on their own and every other escape reads as a space — an escape never glues its hex digits onto the token after it
  *  (`%C2%A0sk-live-…` read escape by escape is `%C2%A0sk-…`, whose tokens are `C2` / `A0sk-…`: the `sk-` boundary is gone,
- *  though any standard decoder restores it). Display-only: the validation detector never reads it. */
+ *  though any standard decoder restores it). Read by both scanners since 11.0.0. */
 function boundaryReading(s) {
     if (s.indexOf("%") === -1)
         return s;
@@ -81,7 +82,8 @@ function boundaryReading(s) {
         return isWellFormedUtf8(bytes) ? decodeURIComponent(run) : bytes.map((b) => (b < 0x80 ? String.fromCharCode(b) : " ")).join("");
     });
 }
-/** The display-side normalization — only `redactSecrets` (config-fns) calls it. */
+/** The normalization BOTH scanners read (11.0.0): the validation detector `containsSecretToken` (types) and the display redactor
+ *  `redactSecrets` (config-fns). */
 export function secretScanForms(text) {
     const layers = percentLayers(text);
     const last = layers[layers.length - 1];
@@ -90,21 +92,41 @@ export function secretScanForms(text) {
     const forms = [...new Set([...readings, ...readings.map((reading) => (reading.indexOf("+") === -1 ? reading : reading.replace(/\+/g, " ")))])];
     return { percentLayers: layers, forms, unresolved };
 }
-/** 「URL 的 userinfo 就是凭据」的**唯一**判定(6.3.0,opus 腿 L1):username / password 任一在场即是。校验侧 `NON_SECRET_URL` 与 https
- *  插件源据此拒写(`./types`),身份面据此否决(`./config-fns` 的 `isDisclosableIdentity` —— `https://admin:hunter2@db…` /
- *  `postgres://svc:pw@h` 的字符全在身份白名单里)。串解析不成 URL ⇒ false:这只判定只说「一个 URL 带没带 userinfo」,
- *  不是 URL 的串不在它的射程里(无 scheme 的 `svc:pw@host` 解析成不透明路径,同样答 false —— 如实登记的边界)。 */
-export function carriesUserinfo(u) {
-    let url;
-    if (typeof u === "string") {
-        try {
-            url = new URL(u);
-        }
-        catch {
-            return false; // 不是 URL:不在这只判定的射程里(见头注),不是回退
+/** 空白(一段文本里候选段的唯一分隔:引号、尖括号、反引号都可能在口令里 —— WHATWG 收 `https://u:p'w@h`)。 */
+const isSpace = (c) => c === " " || c === "\t" || c === "\n" || c === "\r" || c === "\f" || c === "\v" || /\s/.test(c);
+/** 「URL 的 userinfo 就是凭据」的**唯一**判定(6.3.0 起;11.0.0 S-811 扩到自由文本):文本是带 userinfo 的 URL(URL 形判官
+ *  {@link httpUrlFlaws} 判出 `userinfo` 这一件 —— 层级式任意 scheme,`ssh://git@host` 只带用户名也算),或文本里某个 `@` 收尾的那一段
+ *  (从 `@` 向前到空白或上一个 `@`)是凭据对:
+ *   · authority 形 —— 段里最后一个 `//` 到 `@` 之间非空且不含 `/ ? #`(`jdbc:postgresql://svc:pw@…`、`//admin:pw@…`、`ssh://git@h`);
+ *   · 冒号形 —— 段里最后一个 `/ ? #` 之后的那一截是 `user:pw`(两侧非空),且 `@` 后紧跟主机字符(`admin:pw@db:5432/app`、`postgres:/svc:pw@h`)。
+ *  引号 / 尖括号 / 反引号**不**断段(它们可以在口令里)。单遍:每个字符至多被一次向前扫描读到(段以上一个 `@` 为界、互不重叠)⇒ 线性,
+ *  不用回溯正则(codex r1:扫描正则在 `;` × 4 万 + `@` 上要 10 s)。
+ *  读者:展示侧 `redactSecrets`(`./config-fns`)对空白分隔的候选段与归一化形各问一次 —— 自由文本出门面(坐标 / 错误句 / 主机名标签)与身份面
+ *  (`isDisclosableIdentity` 问的就是 `redactSecrets` 原样放不放行)同一条律。校验侧不读它:URL 座位的 userinfo 由 URL 形判官拒,自由文本写口
+ *  不因 userinfo 拒(契约未变)。负控:路径里的 `@`(`https://h/@scope/pkg`)、邮箱、`name@版本`、空 userinfo(`https://@h`)都不是。 */
+export function carriesUserinfo(text) {
+    if (!text.includes("@"))
+        return false; // userinfo ends at an `@` in every form above — no `@`, no credential pair (and no parse)
+    if (httpUrlFlaws(text, ["userinfo"]).includes("userinfo"))
+        return true;
+    let floor = 0; // 上一个 `@` 之后:向前扫描不越过它 ⇒ 各段不重叠
+    for (let at = text.indexOf("@"); at !== -1; at = text.indexOf("@", at + 1)) {
+        let start = at;
+        while (start > floor && !isSpace(text[start - 1]))
+            start--;
+        floor = at + 1;
+        const run = text.slice(start, at);
+        const slashes = run.lastIndexOf("//");
+        if (slashes !== -1) {
+            const userinfo = run.slice(slashes + 2);
+            if (userinfo !== "" && !/[/?#]/.test(userinfo))
+                return true;
         }
+        const tail = run.slice(Math.max(run.lastIndexOf("/"), run.lastIndexOf("?"), run.lastIndexOf("#")) + 1);
+        const colon = tail.indexOf(":");
+        const next = text[at + 1];
+        if (colon > 0 && colon < tail.length - 1 && next !== undefined && next !== "@" && !isSpace(next))
+            return true;
     }
-    else
-        url = u;
-    return url.username !== "" || url.password !== "";
+    return false;
 }

package/dist/sha256-core.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SHA-256 / HMAC-SHA256 的纯 JS 核(内部模块,不在 exports 表里)—— 同步、零依赖、browser-safe。
+ *
+ * 为什么不是 `node:crypto`:读它的模块在纯 barrel 里(内容寻址 `sha256Hex`、按 scope 绑定的令牌 `./api/pull-token`),
+ * 浏览器侧的消费方 import 那只 barrel 拿 zod 型,`node:crypto` 会打断(或用 polyfill 撑胖)它的构建;Web Crypto 只有异步。
+ * 与 `node:crypto` 逐字节同 —— 测试里对拍。
+ */
+/** Encode a JS string to UTF-8 bytes (no Node Buffer / TextEncoder dependency required — but use
+ *  TextEncoder when present for speed; it exists in both modern Node and browsers). */
+export declare function utf8Bytes(s: string): Uint8Array;
+/** SHA-256 of raw bytes → the 32-byte digest. */
+export declare function sha256Digest(msg: Uint8Array): Uint8Array;
+/** Bytes → lowercase hex. */
+export declare function toHex(bytes: Uint8Array): string;
+/** HMAC-SHA256(key, message) over UTF-8 strings → lowercase hex (RFC 2104;块长 64 字节,长于块长的密钥先哈希)。 */
+export declare function hmacSha256Hex(key: string, message: string): string;

package/dist/sha256-core.js

@@ -0,0 +1,138 @@
+/**
+ * SHA-256 / HMAC-SHA256 的纯 JS 核(内部模块,不在 exports 表里)—— 同步、零依赖、browser-safe。
+ *
+ * 为什么不是 `node:crypto`:读它的模块在纯 barrel 里(内容寻址 `sha256Hex`、按 scope 绑定的令牌 `./api/pull-token`),
+ * 浏览器侧的消费方 import 那只 barrel 拿 zod 型,`node:crypto` 会打断(或用 polyfill 撑胖)它的构建;Web Crypto 只有异步。
+ * 与 `node:crypto` 逐字节同 —— 测试里对拍。
+ */
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** Encode a JS string to UTF-8 bytes (no Node Buffer / TextEncoder dependency required — but use
+ *  TextEncoder when present for speed; it exists in both modern Node and browsers). */
+export function utf8Bytes(s) {
+    if (typeof TextEncoder !== "undefined")
+        return new TextEncoder().encode(s);
+    // Minimal fallback encoder (very old runtimes only).
+    const out = [];
+    for (let i = 0; i < s.length; i++) {
+        let c = s.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {
+            const c2 = s.charCodeAt(i + 1);
+            if (c2 >= 0xdc00 && c2 <= 0xdfff) {
+                c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
+                i++;
+            }
+        }
+        if (c < 0x80)
+            out.push(c);
+        else if (c < 0x800)
+            out.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        else if (c < 0x10000)
+            out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        else
+            out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+    }
+    return Uint8Array.from(out);
+}
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+/** SHA-256 of raw bytes → the 32-byte digest. */
+export function sha256Digest(msg) {
+    const bitLen = msg.length * 8;
+    // Pad: 0x80, then zeros, then 64-bit big-endian length, to a multiple of 64 bytes.
+    const withOne = msg.length + 1;
+    const total = withOne + ((56 - (withOne % 64) + 64) % 64) + 8;
+    const buf = new Uint8Array(total);
+    buf.set(msg);
+    buf[msg.length] = 0x80;
+    // 64-bit length, big-endian. bitLen fits in 53 bits safely for any realistic skill body.
+    const hi = Math.floor(bitLen / 0x100000000);
+    const lo = bitLen >>> 0;
+    buf[total - 8] = (hi >>> 24) & 0xff;
+    buf[total - 7] = (hi >>> 16) & 0xff;
+    buf[total - 6] = (hi >>> 8) & 0xff;
+    buf[total - 5] = hi & 0xff;
+    buf[total - 4] = (lo >>> 24) & 0xff;
+    buf[total - 3] = (lo >>> 16) & 0xff;
+    buf[total - 2] = (lo >>> 8) & 0xff;
+    buf[total - 1] = lo & 0xff;
+    let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
+    let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+    const w = new Uint32Array(64);
+    for (let off = 0; off < total; off += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = (buf[off + i * 4] << 24) | (buf[off + i * 4 + 1] << 16) | (buf[off + i * 4 + 2] << 8) | buf[off + i * 4 + 3];
+        }
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+        }
+        let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+        for (let i = 0; i < 64; i++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (h + S1 + ch + K[i] + w[i]) | 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        h0 = (h0 + a) | 0;
+        h1 = (h1 + b) | 0;
+        h2 = (h2 + c) | 0;
+        h3 = (h3 + d) | 0;
+        h4 = (h4 + e) | 0;
+        h5 = (h5 + f) | 0;
+        h6 = (h6 + g) | 0;
+        h7 = (h7 + h) | 0;
+    }
+    const out = new Uint8Array(32);
+    [h0, h1, h2, h3, h4, h5, h6, h7].forEach((h, i) => {
+        out[i * 4] = (h >>> 24) & 0xff;
+        out[i * 4 + 1] = (h >>> 16) & 0xff;
+        out[i * 4 + 2] = (h >>> 8) & 0xff;
+        out[i * 4 + 3] = h & 0xff;
+    });
+    return out;
+}
+/** Bytes → lowercase hex. */
+export function toHex(bytes) {
+    let s = "";
+    for (const byte of bytes)
+        s += byte.toString(16).padStart(2, "0");
+    return s;
+}
+/** HMAC-SHA256(key, message) over UTF-8 strings → lowercase hex (RFC 2104;块长 64 字节,长于块长的密钥先哈希)。 */
+export function hmacSha256Hex(key, message) {
+    let k = utf8Bytes(key);
+    if (k.length > 64)
+        k = sha256Digest(k);
+    const block = new Uint8Array(64);
+    block.set(k);
+    const ipad = block.map((x) => x ^ 0x36);
+    const opad = block.map((x) => x ^ 0x5c);
+    const msg = utf8Bytes(message);
+    const innerInput = new Uint8Array(64 + msg.length);
+    innerInput.set(ipad);
+    innerInput.set(msg, 64);
+    const innerHash = sha256Digest(innerInput);
+    const outerInput = new Uint8Array(64 + 32);
+    outerInput.set(opad);
+    outerInput.set(innerHash, 64);
+    return toHex(sha256Digest(outerInput));
+}

package/dist/sha256.d.ts

@@ -2,7 +2,7 @@
  * Pure, dependency-free, **synchronous** SHA-256 over a UTF-8 string → lowercase hex.
  *
  * WHY a hand-rolled impl instead of `node:crypto`: this module sits in the PURE barrel
- * (re-exported via skills-manifest.ts → resolve-roster.ts → index.ts). sema-registry's CLIENT components
+ * (re-exported via skills-manifest.ts → resolve-roster.ts → index.ts). web-admin's CLIENT components
  * import that barrel for the zod types, so anything in it ships into the BROWSER bundle. A `node:crypto`
  * import there breaks (or bloats with a polyfill) the client build — the exact blocker flagged in review.
  * Web Crypto (`crypto.subtle.digest`) is async-only, but `skillContentHash` is a sync contract used in
@@ -12,5 +12,10 @@
  * node:crypto in the tests — so the `sha256:<hex>` content-address the service re-hashes after pulling
  * (tamper detection) still matches. This is content-addressing/integrity, NOT a secret/MAC.
  */
+import { z } from "zod";
 /** SHA-256 of a UTF-8 string → 64-char lowercase hex. */
 export declare function sha256Hex(input: string): string;
+/** The one spelling of a content digest on the wire: `sha256:` + 64 lowercase hex characters. */
+export declare const SHA256_DIGEST_RE: RegExp;
+/** {@link SHA256_DIGEST_RE} as a schema —— 本包每个装 `sha256:<hex>` 摘要的座位都引它(此前五处各写一遍同一条正则)。 */
+export declare const Sha256Digest: z.ZodString;

package/dist/sha256.js

@@ -2,7 +2,7 @@
  * Pure, dependency-free, **synchronous** SHA-256 over a UTF-8 string → lowercase hex.
  *
  * WHY a hand-rolled impl instead of `node:crypto`: this module sits in the PURE barrel
- * (re-exported via skills-manifest.ts → resolve-roster.ts → index.ts). sema-registry's CLIENT components
+ * (re-exported via skills-manifest.ts → resolve-roster.ts → index.ts). web-admin's CLIENT components
  * import that barrel for the zod types, so anything in it ships into the BROWSER bundle. A `node:crypto`
  * import there breaks (or bloats with a polyfill) the client build — the exact blocker flagged in review.
  * Web Crypto (`crypto.subtle.digest`) is async-only, but `skillContentHash` is a sync contract used in
@@ -12,103 +12,13 @@
  * node:crypto in the tests — so the `sha256:<hex>` content-address the service re-hashes after pulling
  * (tamper detection) still matches. This is content-addressing/integrity, NOT a secret/MAC.
  */
-const K = new Uint32Array([
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-]);
-/** Encode a JS string to UTF-8 bytes (no Node Buffer / TextEncoder dependency required — but use
- *  TextEncoder when present for speed; it exists in both modern Node and browsers). */
-function utf8Bytes(s) {
-    if (typeof TextEncoder !== "undefined")
-        return new TextEncoder().encode(s);
-    // Minimal fallback encoder (very old runtimes only).
-    const out = [];
-    for (let i = 0; i < s.length; i++) {
-        let c = s.charCodeAt(i);
-        if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {
-            const c2 = s.charCodeAt(i + 1);
-            if (c2 >= 0xdc00 && c2 <= 0xdfff) {
-                c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
-                i++;
-            }
-        }
-        if (c < 0x80)
-            out.push(c);
-        else if (c < 0x800)
-            out.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
-        else if (c < 0x10000)
-            out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
-        else
-            out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
-    }
-    return Uint8Array.from(out);
-}
-const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+import { z } from "zod";
+import { sha256Digest, toHex, utf8Bytes } from "./sha256-core.js";
 /** SHA-256 of a UTF-8 string → 64-char lowercase hex. */
 export function sha256Hex(input) {
-    const msg = utf8Bytes(input);
-    const bitLen = msg.length * 8;
-    // Pad: 0x80, then zeros, then 64-bit big-endian length, to a multiple of 64 bytes.
-    const withOne = msg.length + 1;
-    const total = withOne + ((56 - (withOne % 64) + 64) % 64) + 8;
-    const buf = new Uint8Array(total);
-    buf.set(msg);
-    buf[msg.length] = 0x80;
-    // 64-bit length, big-endian. bitLen fits in 53 bits safely for any realistic skill body.
-    const hi = Math.floor(bitLen / 0x100000000);
-    const lo = bitLen >>> 0;
-    buf[total - 8] = (hi >>> 24) & 0xff;
-    buf[total - 7] = (hi >>> 16) & 0xff;
-    buf[total - 6] = (hi >>> 8) & 0xff;
-    buf[total - 5] = hi & 0xff;
-    buf[total - 4] = (lo >>> 24) & 0xff;
-    buf[total - 3] = (lo >>> 16) & 0xff;
-    buf[total - 2] = (lo >>> 8) & 0xff;
-    buf[total - 1] = lo & 0xff;
-    let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
-    let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
-    const w = new Uint32Array(64);
-    for (let off = 0; off < total; off += 64) {
-        for (let i = 0; i < 16; i++) {
-            w[i] = (buf[off + i * 4] << 24) | (buf[off + i * 4 + 1] << 16) | (buf[off + i * 4 + 2] << 8) | buf[off + i * 4 + 3];
-        }
-        for (let i = 16; i < 64; i++) {
-            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
-            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
-            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
-        }
-        let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
-        for (let i = 0; i < 64; i++) {
-            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-            const ch = (e & f) ^ (~e & g);
-            const t1 = (h + S1 + ch + K[i] + w[i]) | 0;
-            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
-            const maj = (a & b) ^ (a & c) ^ (b & c);
-            const t2 = (S0 + maj) | 0;
-            h = g;
-            g = f;
-            f = e;
-            e = (d + t1) | 0;
-            d = c;
-            c = b;
-            b = a;
-            a = (t1 + t2) | 0;
-        }
-        h0 = (h0 + a) | 0;
-        h1 = (h1 + b) | 0;
-        h2 = (h2 + c) | 0;
-        h3 = (h3 + d) | 0;
-        h4 = (h4 + e) | 0;
-        h5 = (h5 + f) | 0;
-        h6 = (h6 + g) | 0;
-        h7 = (h7 + h) | 0;
-    }
-    const toHex = (n) => (n >>> 0).toString(16).padStart(8, "0");
-    return toHex(h0) + toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4) + toHex(h5) + toHex(h6) + toHex(h7);
+    return toHex(sha256Digest(utf8Bytes(input)));
 }
+/** The one spelling of a content digest on the wire: `sha256:` + 64 lowercase hex characters. */
+export const SHA256_DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+/** {@link SHA256_DIGEST_RE} as a schema —— 本包每个装 `sha256:<hex>` 摘要的座位都引它(此前五处各写一遍同一条正则)。 */
+export const Sha256Digest = z.string().regex(SHA256_DIGEST_RE);

package/dist/skills-manifest.js

@@ -9,7 +9,7 @@
  * — distinct from the FNV `stableHash` in hash.ts, which is a fast non-crypto change-detector for ETags.
  *
  * The digest is a PURE-JS sha256 (./sha256.ts), NOT `node:crypto`: this module is re-exported through the
- * package barrel, which sema-registry's CLIENT components import for the zod types — so a `node:crypto`
+ * package barrel, which web-admin's CLIENT components import for the zod types — so a `node:crypto`
  * import here would leak `node:*` into the browser bundle (the review-flagged blocker). Output is byte-identical to
  * `createHash("sha256")`, so the `sha256:<hex>` content-address the service verifies still matches.
  */