hyperframes 0.8.143 → 0.8.144

package/dist/chunk-UPFUC4DB.js

@@ -0,0 +1,136 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  CliUsageError
+} from "./chunk-PBN6GBJE.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+
+// src/utils/reject-unknown-flags.ts
+var ALWAYS_KNOWN = /* @__PURE__ */ new Set(["help", "h", "version", "v", "json"]);
+function nameVariants(name) {
+  const kebab = name.replace(/[A-Z]/g, (c2) => "-" + c2.toLowerCase());
+  const camel = name.replace(/-([a-z])/g, (_, c2) => c2.toUpperCase());
+  return [name, kebab, camel];
+}
+function* spellingsOf(name, def) {
+  yield* nameVariants(name);
+  const alias = def && "alias" in def ? def.alias : void 0;
+  if (typeof alias === "string") yield alias;
+  else if (Array.isArray(alias)) yield* alias;
+}
+function knownFlags(args) {
+  const known = new Set(ALWAYS_KNOWN);
+  for (const [name, def] of Object.entries(args ?? {})) {
+    for (const s of spellingsOf(name, def)) known.add(s);
+  }
+  return known;
+}
+function longFlagName(tok) {
+  const name = tok.slice(2).split("=")[0] ?? "";
+  return name.startsWith("no-") ? name.slice(3) : name;
+}
+function unknownFlagIn(tok, known) {
+  if (tok === "-" || !tok.startsWith("-")) return null;
+  if (tok.startsWith("--")) {
+    const name = longFlagName(tok);
+    return name && !known.has(name) ? `--${name}` : null;
+  }
+  for (const ch of tok.slice(1).split("=")[0] ?? "") {
+    if (!known.has(ch)) return `-${ch}`;
+  }
+  return null;
+}
+function assertKnownFlags(cmd, rawArgs) {
+  if (!Array.isArray(rawArgs)) return;
+  const rawDef = cmd.args;
+  const args = rawDef && typeof rawDef === "object" ? rawDef : void 0;
+  const known = knownFlags(args);
+  for (const tok of rawArgs) {
+    if (tok === "--") break;
+    const bad = unknownFlagIn(tok, known);
+    if (bad) throw new Error(`Unknown flag: ${bad}`);
+  }
+}
+function stringValueFlagOwners(args, ignore) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const [name, def] of Object.entries(args ?? {})) {
+    if (def?.type !== "string" && def?.type !== "enum") continue;
+    if (ignore?.has(name)) continue;
+    for (const s of spellingsOf(name, def)) owners.set(s, name);
+  }
+  return owners;
+}
+function ownableFlagSpelling(tok) {
+  if (tok.includes("=")) return null;
+  if (tok.startsWith("--")) return tok.slice(2);
+  if (tok.length === 2 && tok.startsWith("-")) return tok.slice(1);
+  return null;
+}
+var SWALLOW_REWRITE_FLAGS = {
+  check: /* @__PURE__ */ new Set(["frame-check"])
+};
+var SWALLOW_IGNORE_FLAGS = {
+  upgrade: /* @__PURE__ */ new Set(["project"])
+};
+function swallowedValueMessage(flagName, next, hint) {
+  if (next === "--")
+    return `Missing value for --${flagName}: "--" ends option parsing here; ${hint}`;
+  return `Missing value for --${flagName}: value "${next}" appears to have swallowed the next option; ${hint}`;
+}
+function swallowedFlagUsageError(flagName, next) {
+  const hint = `use --${flagName}= or move --${flagName} to the end`;
+  return new CliUsageError(swallowedValueMessage(flagName, next, hint));
+}
+function throwSwallowedFlagError(flagName, next) {
+  const hint = `pass one: --${flagName} <value> or --${flagName}=<value>`;
+  const message = swallowedValueMessage(flagName, next, hint);
+  console.error(c.error(message));
+  throw new CliUsageError(message, { presented: true });
+}
+function looksLikeSwallowedFlag(next, known) {
+  if (next === void 0 || next === "-") return false;
+  return next === "--" || next.startsWith("-") && unknownFlagIn(next, known) === null;
+}
+function swallowingArgName(tok, next, owners, known) {
+  const spelling = ownableFlagSpelling(tok);
+  const ownerArgName = spelling ? owners.get(spelling) : void 0;
+  return ownerArgName && looksLikeSwallowedFlag(next, known) ? ownerArgName : void 0;
+}
+function rewriteArgName(tok, after, owners, rewriteFlags) {
+  if (!after?.startsWith("--no-")) return void 0;
+  const spelling = ownableFlagSpelling(tok);
+  const name = spelling ? owners.get(spelling) : void 0;
+  return name && rewriteFlags?.has(name) ? name : void 0;
+}
+function guardSwallowedFlagValues(cmd, path, rawArgs) {
+  if (!Array.isArray(rawArgs)) return { rawArgs, rewritten: false };
+  const rawDef = cmd?.args;
+  const argsDef = rawDef && typeof rawDef === "object" ? rawDef : void 0;
+  const known = knownFlags(argsDef);
+  const owners = stringValueFlagOwners(argsDef, SWALLOW_IGNORE_FLAGS[path]);
+  const rewriteFlags = SWALLOW_REWRITE_FLAGS[path];
+  let out;
+  for (const [i, tok] of rawArgs.entries()) {
+    if (tok === "--") break;
+    const next = rawArgs.slice(i + 1).find((t) => !t.startsWith("--no-"));
+    const ownerArgName = swallowingArgName(tok, next, owners, known);
+    const rewrite = rewriteArgName(tok, rawArgs[i + 1], owners, rewriteFlags) ?? ownerArgName;
+    if (!rewrite) continue;
+    if (!rewriteFlags?.has(rewrite)) throwSwallowedFlagError(rewrite, next);
+    out ??= rawArgs.slice();
+    out[i] = `${tok}=`;
+  }
+  return { rawArgs: out ?? rawArgs, rewritten: out !== void 0 };
+}
+
+export {
+  assertKnownFlags,
+  swallowedFlagUsageError,
+  guardSwallowedFlagValues
+};

package/dist/{chunk-BYK73CR7.js → chunk-VYSUZEJG.js}

@@ -20,7 +20,7 @@ import {
 } from "./chunk-3DKN5WKL.js";
 import {
   runEnvironmentChecks
-} from "./chunk-KOEWEFHK.js";
+} from "./chunk-DIRJ322I.js";
 import {
   getAvailableMemoryMb,
   getFreeDiskMb,
@@ -32,18 +32,18 @@ import {
 } from "./chunk-S3S4TGEH.js";
 import {
   resolveExtractCacheDir
-} from "./chunk-33RZPZ4K.js";
+} from "./chunk-5VMR4WBS.js";
 import {
   getUpdateMeta,
   withMeta
-} from "./chunk-Y6QL2LGO.js";
+} from "./chunk-P6WH6QTV.js";
 import {
   CONFIG_PATH,
   withFileLock
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-W35EKBS6.js";
+} from "./chunk-4OC7MQNB.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -232,7 +232,7 @@ function checkEnvironment() {
   return { ok: true, detail: parts.join(" \xB7 ") };
 }
 async function checkWhisper() {
-  const { findWhisper, getInstallInstructions } = await import("./manager-GXYF4AVO.js");
+  const { findWhisper, getInstallInstructions } = await import("./manager-YKMHR6LN.js");
   const result = findWhisper();
   if (result) {
     return { ok: true, detail: result.executablePath };