polycast-cli 0.2.0 → 0.3.0

package/dist/scan.js

@@ -1,74 +1,647 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
-const SKIP_DIRS = new Set([
+const DEFAULT_SKIP_DIRS = [
     "node_modules", "Pods", ".build", "build", "DerivedData", ".git",
     ".swiftpm", "Carthage",
-]);
-export const DEFAULT_SCAN_CALLS = ["Text", "PText", "Polycast.string"];
-/** Build the call matcher from default + user-configured component names.
- * Plain names ("AppText") match constructor/function calls; names starting
- * with "." (".navigationTitle") match method calls. */
-export function buildCallMatcher(extra = []) {
-    const names = [...new Set([...DEFAULT_SCAN_CALLS, ...extra])];
-    const ctors = names.filter((n) => !n.startsWith("."))
-        .map((n) => n.replace(/[.\\]/g, "\\$&"));
-    const methods = names.filter((n) => n.startsWith("."))
-        .map((n) => n.slice(1).replace(/[.\\]/g, "\\$&"));
-    const parts = [];
-    if (ctors.length)
-        parts.push(`(?<![A-Za-z0-9_.])(?:${ctors.join("|")})`);
-    if (methods.length)
-        parts.push(`\\.(?:${methods.join("|")})`);
-    // Optional first-argument label: ContinueButton(title: "…") — the label
-    // is captured so scanFile can skip non-display ones (verbatim:, id:, …).
-    return new RegExp(`(?:${parts.join("|")})\\(\\s*(?:([A-Za-z_][A-Za-z0-9_]*)\\s*:\\s*)?"`, "g");
-}
+];
+export const DEFAULT_SCAN_CALLS = [
+    "Text", "PText", "Polycast.string", "NSLocalizedString",
+    ".navigationTitle", ".accessibilityLabel", ".accessibilityHint",
+    ".accessibilityValue", "WindowGroup", "CommandMenu", "LocalizedStringKey",
+];
+/** `.prop = "literal"` assignment targets captured by default. */
+export const DEFAULT_ASSIGN_PROPS = [
+    "title", "body", "text", "subtitle", "message", "alertMessage",
+    "localizedReason", "localizedFallbackTitle", "placeholder",
+];
 /** First-argument labels that mark a NON-display string. */
 const SKIP_LABELS = new Set([
     "verbatim", "systemImage", "id", "tag", "key", "icon", "imageName",
     "named", "systemName", "url", "rawValue", "identifier",
 ]);
-/** Parse a Swift string literal starting AFTER the opening quote.
- * Interpolations (`\(…)`, balanced) become %@. Returns null for
- * multiline/unterminated literals. */
-function parseLiteral(src, start) {
-    let key = "";
+/** Only Polycast's own calls treat `, count:` as a CLDR plural marker —
+ * custom components may have unrelated count: params (badge counts etc.),
+ * and a plural entry without a numeric specifier breaks Xcode's catalog
+ * compile. */
+const PLURAL_CAPABLE = new Set(["Text", "PText", "Polycast.string"]);
+const OP_CHARS = new Set([..."-+*/%<>=!&|^~?"]);
+const PUNCT_CHARS = new Set([..."()[]{},:;.@#$\\"]);
+function isIdentStart(ch) {
+    return (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z") || ch === "_";
+}
+function isIdentChar(ch) {
+    return isIdentStart(ch) || (ch >= "0" && ch <= "9");
+}
+function isRawStringStart(src, i) {
+    let j = i;
+    while (src[j] === "#")
+        j++;
+    return src[j] === '"';
+}
+function skipBlockComment(src, i) {
+    // i points just past the opening "/*"; block comments nest in Swift.
+    let depth = 1;
+    const n = src.length;
+    while (i < n && depth > 0) {
+        if (src[i] === "/" && src[i + 1] === "*") {
+            depth++;
+            i += 2;
+        }
+        else if (src[i] === "*" && src[i + 1] === "/") {
+            depth--;
+            i += 2;
+        }
+        else
+            i++;
+    }
+    return i;
+}
+/** Decode one escape sequence; `e` points at the char after `\` (+ #s).
+ * Returns [decoded text, chars consumed starting at e]. */
+function decodeEscape(src, e) {
+    const c = src[e];
+    switch (c) {
+        case "n": return ["\n", 1];
+        case "t": return ["\t", 1];
+        case "r": return ["\r", 1];
+        case "0": return ["\0", 1];
+        case "\\": return ["\\", 1];
+        case '"': return ['"', 1];
+        case "'": return ["'", 1];
+        case "u": {
+            if (src[e + 1] === "{") {
+                const close = src.indexOf("}", e + 2);
+                const hex = close > 0 ? src.slice(e + 2, close) : "";
+                if (hex.length >= 1 && hex.length <= 8 && /^[0-9a-fA-F]+$/.test(hex)) {
+                    try {
+                        return [String.fromCodePoint(parseInt(hex, 16)), close - e + 1];
+                    }
+                    catch { /* invalid scalar — fall through */ }
+                }
+            }
+            return ["u", 1];
+        }
+        default: return [c ?? "", 1];
+    }
+}
+/** Skip a balanced `\(…)` interpolation body; `i` points just past the
+ * opening paren. String-literal and comment aware, so a ")" inside a
+ * nested string (e.g. `\(x, specifier: "%.1f")`) can't end it early. */
+function skipInterpolation(src, i) {
+    const n = src.length;
+    let depth = 1;
+    while (i < n && depth > 0) {
+        const ch = src[i];
+        if (ch === '"' || (ch === "#" && isRawStringStart(src, i))) {
+            i = parseString(src, i).end;
+            continue;
+        }
+        if (ch === "/" && src[i + 1] === "/") {
+            while (i < n && src[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (ch === "/" && src[i + 1] === "*") {
+            i = skipBlockComment(src, i + 2);
+            continue;
+        }
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        i++;
+    }
+    return i;
+}
+/** Parse any Swift string literal starting at `start` (at the first `#`
+ * for raw strings, else at the opening quote). */
+function parseString(src, start) {
     let i = start;
-    while (i < src.length) {
+    let pounds = 0;
+    while (src[i] === "#") {
+        pounds++;
+        i++;
+    }
+    const hashes = "#".repeat(pounds);
+    const multiline = src.startsWith('"""', i);
+    i += multiline ? 3 : 1;
+    return multiline
+        ? parseMultilineString(src, i, pounds, hashes)
+        : parseSingleLineString(src, i, pounds, hashes);
+}
+function parseSingleLineString(src, i, pounds, hashes) {
+    const n = src.length;
+    const parts = [];
+    let lit = "";
+    while (i < n) {
         const ch = src[i];
-        if (ch === '"')
-            return { key, end: i + 1 };
         if (ch === "\n")
+            break; // unterminated — tolerate, end at the newline
+        if (ch === '"' && src.startsWith(hashes, i + 1)) {
+            i += 1 + pounds;
+            break;
+        }
+        // In a raw string, `\` only escapes when followed by the matching #s.
+        if (ch === "\\" && src.startsWith(hashes, i + 1)) {
+            const e = i + 1 + pounds;
+            if (src[e] === "(") {
+                parts.push(lit, null);
+                lit = "";
+                i = skipInterpolation(src, e + 1);
+                continue;
+            }
+            const [decoded, len] = decodeEscape(src, e);
+            lit += decoded;
+            i = e + len;
+            continue;
+        }
+        lit += ch;
+        i++;
+    }
+    parts.push(lit);
+    return { parts, end: i };
+}
+function parseMultilineString(src, i, pounds, hashes) {
+    const n = src.length;
+    // Pass 1: locate the closing delimiter (escape/interpolation aware).
+    let close = n;
+    {
+        let j = i;
+        while (j < n) {
+            const ch = src[j];
+            if (ch === "\\" && src.startsWith(hashes, j + 1)) {
+                const e = j + 1 + pounds;
+                j = src[e] === "(" ? skipInterpolation(src, e + 1) : e + 1;
+                continue;
+            }
+            if (ch === '"' && src.startsWith('""' + hashes, j + 1)) {
+                close = j;
+                break;
+            }
+            j++;
+        }
+    }
+    const end = Math.min(close + 3 + pounds, n);
+    // Swift strips the closing delimiter's indentation from every line and
+    // drops the newlines adjacent to the delimiters.
+    const lastNL = src.lastIndexOf("\n", close - 1);
+    let indent = "";
+    let contentEnd = close;
+    if (lastNL >= i) {
+        const maybe = src.slice(lastNL + 1, close);
+        if (/^[ \t]*$/.test(maybe)) {
+            indent = maybe;
+            contentEnd = lastNL;
+        }
+    }
+    let contentStart = i;
+    const firstNL = src.indexOf("\n", i);
+    if (firstNL !== -1 && firstNL < contentEnd)
+        contentStart = firstNL + 1;
+    // Pass 2: decode content.
+    const parts = [];
+    let lit = "";
+    let j = contentStart;
+    let atLineStart = true;
+    while (j < contentEnd) {
+        if (atLineStart) {
+            atLineStart = false;
+            if (indent.length > 0 && src.startsWith(indent, j))
+                j += indent.length;
+            continue;
+        }
+        const ch = src[j];
+        if (ch === "\\" && src.startsWith(hashes, j + 1)) {
+            const e = j + 1 + pounds;
+            const esc = src[e];
+            if (esc === "(") {
+                parts.push(lit, null);
+                lit = "";
+                j = skipInterpolation(src, e + 1);
+                continue;
+            }
+            if (esc === "\n" || (esc === "\r" && src[e + 1] === "\n")) {
+                // line continuation: `\` at end of line eats the newline
+                j = esc === "\n" ? e + 1 : e + 2;
+                atLineStart = true;
+                continue;
+            }
+            const [decoded, len] = decodeEscape(src, e);
+            lit += decoded;
+            j = e + len;
+            continue;
+        }
+        if (ch === "\r") {
+            j++;
+            continue;
+        }
+        if (ch === "\n") {
+            lit += "\n";
+            j++;
+            atLineStart = true;
+            continue;
+        }
+        lit += ch;
+        j++;
+    }
+    parts.push(lit);
+    return { parts, end };
+}
+function lex(src) {
+    const toks = [];
+    const n = src.length;
+    let i = 0;
+    while (i < n) {
+        const ch = src[i];
+        if (ch === " " || ch === "\t" || ch === "\r" || ch === "\n") {
+            i++;
+            continue;
+        }
+        if (ch === "/" && src[i + 1] === "/") {
+            while (i < n && src[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (ch === "/" && src[i + 1] === "*") {
+            i = skipBlockComment(src, i + 2);
+            continue;
+        }
+        if (ch === '"' || (ch === "#" && isRawStringStart(src, i))) {
+            const s = parseString(src, i);
+            toks.push({ t: "str", parts: s.parts });
+            i = s.end;
+            continue;
+        }
+        if (isIdentStart(ch)) {
+            let j = i + 1;
+            while (j < n && isIdentChar(src[j]))
+                j++;
+            toks.push({ t: "id", v: src.slice(i, j) });
+            i = j;
+            continue;
+        }
+        if (ch === "`") { // escaped identifier: `default`
+            let j = i + 1;
+            while (j < n && src[j] !== "`" && src[j] !== "\n")
+                j++;
+            toks.push({ t: "id", v: src.slice(i + 1, j) });
+            i = j + 1;
+            continue;
+        }
+        if (ch >= "0" && ch <= "9") {
+            let j = i + 1;
+            while (j < n && (isIdentChar(src[j]) || (src[j] === "." && (src[j + 1] ?? "") >= "0" && (src[j + 1] ?? "") <= "9")))
+                j++;
+            toks.push({ t: "num" });
+            i = j;
+            continue;
+        }
+        if (OP_CHARS.has(ch)) {
+            let j = i;
+            while (j < n && OP_CHARS.has(src[j]) &&
+                !(src[j] === "/" && (src[j + 1] === "/" || src[j + 1] === "*")))
+                j++;
+            if (j > i) {
+                toks.push({ t: "op", v: src.slice(i, j) });
+                i = j;
+                continue;
+            }
+        }
+        if (PUNCT_CHARS.has(ch)) {
+            toks.push({ t: "p", v: ch });
+            i++;
+            continue;
+        }
+        i++; // anything else (unicode operators, emoji in code) is inert
+    }
+    return toks;
+}
+/** Fold adjacent `"a" + "b"` literal concatenations (possibly across
+ * newlines) into one string token, chains included — the runtime sees a
+ * single string, so the catalog must too. */
+function foldConcat(toks) {
+    const out = [];
+    for (const t of toks) {
+        const plus = out[out.length - 1];
+        const left = out[out.length - 2];
+        if (t.t === "str" && plus?.t === "op" && plus.v === "+" && left?.t === "str") {
+            out.pop();
+            left.parts = [...left.parts, ...t.parts];
+            continue;
+        }
+        out.push(t);
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Key building + classification
+// ---------------------------------------------------------------------------
+/** Build the catalog key from decoded parts. Interpolations render as %@;
+ * literal "%" doubles to "%%" ONLY when at least one interpolation exists
+ * (parity with PolycastFormatString at runtime). */
+function keyFromParts(parts) {
+    const hasInterp = parts.some((p) => p === null);
+    let out = "";
+    for (const p of parts)
+        out += p === null ? "%@" : hasInterp ? p.replace(/%/g, "%%") : p;
+    return out;
+}
+const SPECIFIER_RE = /%(?:\d+\$)?[-+#0']*\d*(?:\.\d+)?(?:hh|h|ll|l|q|z|t|L)?[@diouxXeEfgGaAcspSCF]/g;
+const JOINER_RE = /[@·–—%°/:]/;
+/** Keep letterful keys as normal strings. Letterless keys survive only as
+ * `structural` joiners: >=2 format specifiers, or >=1 specifier plus a
+ * joiner character. Empty / pure-emoji / single-specifier-only keys drop
+ * (not translatable; they also break Xcode's catalog symbol generation). */
+function classifyKey(key) {
+    if (key.trim().length === 0)
+        return { keep: false, structural: false };
+    const guarded = key.replace(/%%/g, "\uE000\uE000"); // protect escaped percents
+    const specifiers = guarded.match(SPECIFIER_RE)?.length ?? 0;
+    const residual = guarded.replace(SPECIFIER_RE, "").replace(/\uE000/g, "%");
+    if (/\p{L}/u.test(residual))
+        return { keep: true, structural: false };
+    if (specifiers >= 2 || (specifiers >= 1 && JOINER_RE.test(residual))) {
+        return { keep: true, structural: true };
+    }
+    return { keep: false, structural: false };
+}
+function compileRegistry(extra) {
+    const names = [...new Set([...DEFAULT_SCAN_CALLS, ...extra])];
+    const ctors = [];
+    const methods = new Set();
+    const labels = new Set();
+    for (const n of names) {
+        if (n.startsWith("."))
+            methods.add(n.slice(1));
+        else if (n.endsWith(":"))
+            labels.add(n.slice(0, -1));
+        else
+            ctors.push({
+                name: n,
+                segs: n.split("."),
+                firstOnly: n === "NSLocalizedString",
+                requiredLabel: undefined,
+                pluralCapable: PLURAL_CAPABLE.has(n),
+            });
+    }
+    // Foundation localized-string ctors: only the `localized:` argument is a
+    // key — String(format:…) / String(describing:…) must never be captured.
+    for (const n of ["String", "AttributedString"]) {
+        if (!ctors.some((c) => c.name === n)) {
+            ctors.push({ name: n, segs: [n], firstOnly: false, requiredLabel: "localized", pluralCapable: false });
+        }
+    }
+    return { ctors, methods, labels };
+}
+function tokIs(t, kind, v) {
+    if (t === undefined)
+        return false;
+    return (t.t === "p" || t.t === "op") && t.t === kind && t.v === v;
+}
+function tokId(t) {
+    return t !== undefined && t.t === "id" ? t.v : undefined;
+}
+/** Match a registered call name at token j. Handles dotted names
+ * ("Polycast.string"), a `SwiftUI.` qualifier (marked native), and a
+ * trailing `.init`. Rejects other qualified accesses (Foo.Text) — and
+ * `RichText(` can never match `Text` because identifiers are whole
+ * tokens. */
+function matchCtor(toks, j, spec) {
+    if (tokId(toks[j]) !== spec.segs[0])
+        return null;
+    let native = false;
+    const prev = toks[j - 1];
+    if (prev !== undefined && prev.t === "p" && prev.v === ".") {
+        if (tokId(toks[j - 2]) !== "SwiftUI" || tokIs(toks[j - 3], "p", "."))
             return null;
-        if (ch === "\\") {
-            const next = src[i + 1];
-            if (next === "(") { // interpolation — swallow balanced parens
-                let depth = 1;
-                i += 2;
-                while (i < src.length && depth > 0) {
-                    if (src[i] === "(")
-                        depth++;
-                    else if (src[i] === ")")
-                        depth--;
-                    i++;
+        native = true;
+    }
+    let k = j + 1;
+    for (let s = 1; s < spec.segs.length; s++) {
+        if (!tokIs(toks[k], "p", ".") || tokId(toks[k + 1]) !== spec.segs[s])
+            return null;
+        k += 2;
+    }
+    if (tokIs(toks[k], "p", ".") && tokId(toks[k + 1]) === "init")
+        k += 2; // Text.init(
+    if (!tokIs(toks[k], "p", "("))
+        return null;
+    return { open: k, native };
+}
+const GENERIC_POLICY = { firstOnly: false, requiredLabel: undefined, pluralCapable: false };
+/** The label immediately preceding a literal (`label: "…"`), if any.
+ * `ident :` counts as an argument label ONLY when the identifier itself
+ * follows `(` or `,` — in `cond ? ident : "literal"` the identifier is a
+ * ternary operand, not a label, and the literal must stay capturable
+ * (variable names like `key`/`id`/`url` collide with SKIP_LABELS). */
+function literalLabel(toks, j) {
+    if (!tokIs(toks[j - 1], "p", ":"))
+        return undefined;
+    const label = tokId(toks[j - 2]);
+    if (label === undefined)
+        return undefined;
+    if (!tokIs(toks[j - 3], "p", "(") && !tokIs(toks[j - 3], "p", ","))
+        return undefined;
+    return label;
+}
+/** Capture every top-level string literal in the balanced argument list
+ * starting after the "(" at `open`. Literals inside nested closures
+ * `{ … }` or subscripts/collection literals `[ … ]` are not display
+ * strings for this call and are skipped; so are literals inside a NESTED
+ * call's parens (identifier right before `(`) — they are that call's
+ * arguments, which the runtime can never match against this key (a
+ * registered nested call gets its own region via runCapture; pure
+ * grouping parens don't count). Literals glued to `+` with a non-literal
+ * operand are unfoldable concatenation fragments and are skipped too
+ * (foldConcat already merged literal+literal). SKIP-labelled literals are
+ * skipped; a `comment:`-labelled literal becomes the translator note.
+ * Required-label policies (String(localized:…)) accept the labelled
+ * literal itself plus expression-position literals after the label
+ * (`String(localized: flag ? "Alpha" : "Beta")` captures both). */
+function scanCallRegion(toks, open, policy, native, emit) {
+    let depth = 1;
+    let brace = 0;
+    let bracket = 0;
+    let nestedCall = 0;
+    const parenIsCall = [];
+    let requiredSeen = false;
+    let comment;
+    const hits = [];
+    for (let j = open + 1; j < toks.length && depth > 0; j++) {
+        const t = toks[j];
+        if (t.t === "p") {
+            if (t.v === "(") {
+                depth++;
+                const isCall = tokId(toks[j - 1]) !== undefined;
+                parenIsCall.push(isCall);
+                if (isCall)
+                    nestedCall++;
+            }
+            else if (t.v === ")") {
+                depth--;
+                if (depth > 0 && parenIsCall.pop() === true)
+                    nestedCall--;
+            }
+            else if (t.v === "{")
+                brace++;
+            else if (t.v === "}")
+                brace = brace > 0 ? brace - 1 : 0;
+            else if (t.v === "[")
+                bracket++;
+            else if (t.v === "]")
+                bracket = bracket > 0 ? bracket - 1 : 0;
+            continue;
+        }
+        if (t.t === "id") {
+            // `localized:` seen in argument-label position at this call's top
+            // level → expression-position literals after it are the key.
+            if (policy.requiredLabel !== undefined && t.v === policy.requiredLabel &&
+                depth === 1 && brace === 0 && bracket === 0 &&
+                tokIs(toks[j + 1], "p", ":") &&
+                (tokIs(toks[j - 1], "p", "(") || tokIs(toks[j - 1], "p", ","))) {
+                requiredSeen = true;
+            }
+            continue;
+        }
+        if (t.t !== "str" || brace > 0 || bracket > 0 || nestedCall > 0)
+            continue;
+        if (tokIs(toks[j - 1], "op", "+") || tokIs(toks[j + 1], "op", "+"))
+            continue;
+        const label = literalLabel(toks, j);
+        if (label === "comment") {
+            const c = keyFromParts(t.parts);
+            if (c.trim().length > 0 && comment === undefined)
+                comment = c;
+            continue;
+        }
+        if (label !== undefined && SKIP_LABELS.has(label))
+            continue;
+        if (policy.requiredLabel !== undefined && label !== policy.requiredLabel &&
+            !(label === undefined && requiredSeen))
+            continue;
+        if (policy.firstOnly && hits.length > 0)
+            continue;
+        // `, count:` right after the call's first literal marks a CLDR plural.
+        const plural = policy.pluralCapable && hits.length === 0 &&
+            tokIs(toks[j + 1], "p", ",") && tokId(toks[j + 2]) === "count" && tokIs(toks[j + 3], "p", ":");
+        hits.push({ parts: t.parts, kind: plural ? "plural" : "simple" });
+    }
+    for (const h of hits)
+        emit({ key: keyFromParts(h.parts), kind: h.kind, comment, native });
+}
+function runCapture(toks, reg, assignProps, emit) {
+    for (let j = 0; j < toks.length; j++) {
+        const t = toks[j];
+        if (t.t === "id") {
+            // Registered calls (incl. SwiftUI.-qualified and .init spellings).
+            for (const spec of reg.ctors) {
+                const m = matchCtor(toks, j, spec);
+                if (m !== null) {
+                    scanCallRegion(toks, m.open, spec, m.native, emit);
+                    break;
                 }
-                key += "%@";
+            }
+            // "title:"-style registered labels, any argument position. Never
+            // after a dot (that's a member access, e.g. `case .title:`).
+            if (reg.labels.has(t.v) && tokIs(toks[j + 1], "p", ":") && !tokIs(toks[j - 1], "p", ".")) {
+                const s = toks[j + 2];
+                if (s?.t === "str")
+                    emit({ key: keyFromParts(s.parts), kind: "simple", comment: undefined, native: false });
+            }
+            continue;
+        }
+        if (t.t === "p" && t.v === ".") {
+            const name = tokId(toks[j + 1]);
+            if (name === undefined)
                 continue;
+            // Method-style: view.navigationTitle("…")
+            if (reg.methods.has(name) && tokIs(toks[j + 2], "p", "(")) {
+                scanCallRegion(toks, j + 2, GENERIC_POLICY, false, emit);
+            }
+            // Assignment shape: label.text = "…" (never `==` — that's one op token)
+            if (assignProps.has(name) && tokIs(toks[j + 2], "op", "=")) {
+                const s = toks[j + 3];
+                if (s?.t === "str")
+                    emit({ key: keyFromParts(s.parts), kind: "simple", comment: undefined, native: false });
             }
-            key += next === "n" ? "\n" : next === "t" ? "\t" : next ?? "";
-            i += 2;
             continue;
         }
-        key += ch;
-        i++;
+        // Typed defaults: `: String = "…"` / `: String? = "…"` (vars, lets,
+        // and function default parameters alike).
+        if (t.t === "p" && t.v === ":" && tokId(toks[j + 1]) === "String") {
+            let m = j + 2;
+            if (tokIs(toks[m], "op", "?"))
+                m++;
+            if (tokIs(toks[m], "op", "=") || (m === j + 2 && tokIs(toks[m], "op", "?="))) {
+                const s = toks[m + 1];
+                if (s?.t === "str")
+                    emit({ key: keyFromParts(s.parts), kind: "simple", comment: undefined, native: false });
+            }
+        }
     }
-    return null;
 }
-export function scanSwiftSources(root, extraCalls = []) {
-    const matcher = buildCallMatcher(extraCalls);
+// ---------------------------------------------------------------------------
+// File-system walk
+// ---------------------------------------------------------------------------
+/** Best-effort discovery of local SPM path dependencies:
+ * `.package(path: "…")` (optionally with a leading `name:`) in the root's
+ * Package.swift. */
+function packagePathDeps(root) {
+    const manifest = path.join(root, "Package.swift");
+    if (!existsSync(manifest))
+        return [];
+    let src;
+    try {
+        src = readFileSync(manifest, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const deps = [];
+    for (const m of src.matchAll(/\.package\s*\(\s*(?:name\s*:\s*"[^"]*"\s*,\s*)?path\s*:\s*"([^"]+)"/g)) {
+        deps.push(path.resolve(root, m[1]));
+    }
+    return deps;
+}
+export function scanSwiftSourcesDetailed(root, opts = {}) {
+    const mainRoot = path.resolve(root);
+    const reg = compileRegistry(opts.extraCalls ?? []);
+    const assignProps = new Set(opts.assignProps ?? DEFAULT_ASSIGN_PROPS);
+    const maxDepth = opts.maxDepth ?? 12;
+    const skipDirs = new Set(opts.skipDirs ?? DEFAULT_SKIP_DIRS);
+    const candidates = [mainRoot];
+    for (const r of opts.extraRoots ?? [])
+        candidates.push(path.resolve(mainRoot, r));
+    candidates.push(...packagePathDeps(mainRoot));
     const found = new Map();
+    const stats = { filesScanned: 0, dirsSkipped: [], rootsScanned: [] };
+    const seenFiles = new Set();
+    const emitFor = (file) => (c) => {
+        const cls = classifyKey(c.key);
+        if (!cls.keep)
+            return;
+        const prev = found.get(c.key);
+        if (prev === undefined) {
+            const s = { key: c.key, kind: c.kind, file: path.relative(mainRoot, file) };
+            if (c.comment !== undefined)
+                s.comment = c.comment;
+            if (cls.structural)
+                s.structural = true;
+            if (c.native)
+                s.native = true;
+            found.set(c.key, s);
+            return;
+        }
+        if (prev.kind === "simple" && c.kind === "plural")
+            prev.kind = "plural";
+        if (prev.comment === undefined && c.comment !== undefined)
+            prev.comment = c.comment;
+        // `native` only survives when EVERY occurrence is SwiftUI-qualified.
+        if (prev.native === true && !c.native)
+            delete prev.native;
+    };
     const walk = (dir, depth) => {
-        if (depth > 8)
+        if (depth > maxDepth)
             return;
         let entries;
         try {
@@ -78,9 +651,15 @@ export function scanSwiftSources(root, extraCalls = []) {
             return;
         }
         for (const name of entries) {
-            if (name.startsWith(".") || SKIP_DIRS.has(name))
-                continue;
             const full = path.join(dir, name);
+            if (name.startsWith(".") || skipDirs.has(name)) {
+                try {
+                    if (statSync(full).isDirectory())
+                        stats.dirsSkipped.push(full);
+                }
+                catch { /* ignore */ }
+                continue;
+            }
             let st;
             try {
                 st = statSync(full);
@@ -88,97 +667,51 @@ export function scanSwiftSources(root, extraCalls = []) {
             catch {
                 continue;
             }
-            if (st.isDirectory())
+            if (st.isDirectory()) {
                 walk(full, depth + 1);
-            else if (name.endsWith(".swift"))
-                scanFile(full, root, found, matcher);
-        }
-    };
-    walk(root, 0);
-    return [...found.values()].sort((a, b) => (a.key < b.key ? -1 : 1));
-}
-/** Blank out line and block comments (string-literal aware) so doc
- * examples like `Text("…")` never get captured. Nested blocks handled. */
-export function stripComments(src) {
-    const out = [...src];
-    let i = 0, inString = false, block = 0;
-    while (i < src.length) {
-        const ch = src[i], next = src[i + 1];
-        if (block > 0) {
-            if (ch === "/" && next === "*") {
-                block++;
-                out[i] = out[i + 1] = " ";
-                i += 2;
                 continue;
             }
-            if (ch === "*" && next === "/") {
-                block--;
-                out[i] = out[i + 1] = " ";
-                i += 2;
+            if (!name.endsWith(".swift") || seenFiles.has(full))
+                continue;
+            seenFiles.add(full);
+            if (opts.fileFilter !== undefined && !opts.fileFilter(path.relative(mainRoot, full)))
                 continue;
+            let src;
+            try {
+                src = readFileSync(full, "utf8");
             }
-            if (ch !== "\n")
-                out[i] = " ";
-            i++;
-            continue;
-        }
-        if (inString) {
-            if (ch === "\\") {
-                i += 2;
+            catch {
                 continue;
             }
-            if (ch === '"')
-                inString = false;
-            i++;
-            continue;
+            stats.filesScanned++;
+            try {
+                runCapture(foldConcat(lex(src)), reg, assignProps, emitFor(full));
+            }
+            catch { /* a scanner must never fail the push — skip pathological files */ }
         }
-        if (ch === '"') {
-            inString = true;
-            i++;
+    };
+    const seenRoots = new Set();
+    for (const r of candidates) {
+        if (seenRoots.has(r))
             continue;
+        seenRoots.add(r);
+        let st;
+        try {
+            st = statSync(r);
         }
-        if (ch === "/" && next === "/") {
-            while (i < src.length && src[i] !== "\n") {
-                out[i] = " ";
-                i++;
-            }
+        catch {
             continue;
         }
-        if (ch === "/" && next === "*") {
-            block = 1;
-            out[i] = out[i + 1] = " ";
-            i += 2;
+        if (!st.isDirectory())
             continue;
-        }
-        i++;
+        stats.rootsScanned.push(r);
+        walk(r, 0);
     }
-    return out.join("");
+    const strings = [...found.values()].sort((a, b) => (a.key < b.key ? -1 : 1));
+    return { strings, stats };
 }
-function scanFile(file, root, found, matcher) {
-    const src = stripComments(readFileSync(file, "utf8"));
-    for (const m of src.matchAll(matcher)) {
-        if (m[1] && SKIP_LABELS.has(m[1]))
-            continue;
-        const literalStart = m.index + m[0].length;
-        const parsed = parseLiteral(src, literalStart);
-        if (!parsed || parsed.key.trim().length === 0)
-            continue;
-        // Not translatable content: emoji, separators, SF Symbol names,
-        // format-only strings — anything without a letter. (Also what makes
-        // Xcode's catalog symbol generation choke.)
-        if (!/\p{L}/u.test(parsed.key.replace(/%[@a-zA-Z]+/g, "")))
-            continue;
-        // `, count:` marks a CLDR plural — but only on Polycast's own calls.
-        // Custom components (scanCalls) may have unrelated count: params
-        // (badge counts etc.), and a plural entry without a numeric format
-        // specifier breaks Xcode's catalog compile.
-        const callee = m[0].replace(/\(.*$/s, "").replace(/^\./, "");
-        const pluralCapable = DEFAULT_SCAN_CALLS.includes(callee);
-        const kind = pluralCapable && /^\s*,\s*count\s*:/.test(src.slice(parsed.end)) ? "plural" : "simple";
-        const existing = found.get(parsed.key);
-        if (!existing || (existing.kind === "simple" && kind === "plural")) {
-            found.set(parsed.key, { key: parsed.key, kind, file: path.relative(root, file) });
-        }
-    }
+/** Back-compat wrapper — same shape the CLI has always consumed. */
+export function scanSwiftSources(root, extraCalls = []) {
+    return scanSwiftSourcesDetailed(root, { extraCalls }).strings;
 }
 //# sourceMappingURL=scan.js.map