@deftai/directive-core 0.55.0

package/dist/platform/ip-risk.js

@@ -0,0 +1,235 @@
+import { wordBoundaryMatch } from "./linear-scan.js";
+const BRANDED_GAMES_AND_UNIVERSES = [
+    "Magic: The Gathering",
+    "Magic the Gathering",
+    "MTG",
+    "Yu-Gi-Oh",
+    "Yugioh",
+    "Pokemon",
+    "Pokémon",
+    "Dungeons and Dragons",
+    "Dungeons & Dragons",
+    "D&D",
+    "Warhammer",
+    "Mario",
+    "Zelda",
+    "Final Fantasy",
+    "Halo",
+    "Call of Duty",
+    "Fortnite",
+    "Minecraft",
+    "Roblox",
+    "League of Legends",
+    "World of Warcraft",
+    "WoW",
+    "Overwatch",
+    "Counter-Strike",
+    "Valorant",
+    "Apex Legends",
+    "Star Wars",
+    "Star Trek",
+    "Marvel",
+    "DC Comics",
+    "Harry Potter",
+    "Lord of the Rings",
+    "Middle-earth",
+    "Game of Thrones",
+    "Westeros",
+    "Disney",
+    "Pixar",
+];
+const BRANDED_CHARACTERS = [
+    "Mickey Mouse",
+    "Spider-Man",
+    "Spiderman",
+    "Batman",
+    "Superman",
+    "Wonder Woman",
+    "Iron Man",
+    "Hulk",
+    "Captain America",
+    "Pikachu",
+    "Sonic the Hedgehog",
+    "Luigi",
+    "Princess Peach",
+    "Kirby",
+    "Master Chief",
+    "Lara Croft",
+    "Indiana Jones",
+    "James Bond",
+];
+const SPORTS_LEAGUES = [
+    "NFL",
+    "NBA",
+    "MLB",
+    "NHL",
+    "MLS",
+    "FIFA",
+    "UEFA",
+    "Premier League",
+    "La Liga",
+    "Bundesliga",
+    "Olympics",
+    "Olympic Games",
+    "Super Bowl",
+    "World Cup",
+];
+const BRANDED_PRODUCTS = [
+    "iPhone",
+    "iPad",
+    "MacBook",
+    "AirPods",
+    "PlayStation",
+    "Xbox",
+    "Nintendo Switch",
+    "Coca-Cola",
+    "Pepsi",
+    "Starbucks",
+    "McDonald's",
+    "Lego",
+    "Barbie",
+    "Hot Wheels",
+];
+const MUSIC_AND_FILM = [
+    "Taylor Swift",
+    "Beyonce",
+    "Beyoncé",
+    "Spotify",
+    "Netflix",
+    "Hulu",
+    "HBO",
+];
+const FICTIONAL_UNIVERSE_TERMS = [
+    "Hogwarts",
+    "Jedi",
+    "Sith",
+    "Death Star",
+    "Hobbit",
+    "Vulcan",
+    "Klingon",
+    "Mandalorian",
+    "Force-sensitive",
+    "Muggle",
+    "Quidditch",
+    "Tatooine",
+];
+const CATEGORIES = {
+    "branded-game-or-universe": BRANDED_GAMES_AND_UNIVERSES,
+    "branded-character": BRANDED_CHARACTERS,
+    "sports-league": SPORTS_LEAGUES,
+    "branded-product": BRANDED_PRODUCTS,
+    "music-or-film": MUSIC_AND_FILM,
+    "fictional-universe-term": FICTIONAL_UNIVERSE_TERMS,
+};
+const VALID_INTENTS = new Set(["personal", "commercial", "unknown"]);
+function validateIntent(intent) {
+    if (typeof intent !== "string") {
+        throw new Error(`monetization_intent must be a string, got ${typeof intent}`);
+    }
+    const normalized = intent.trim().toLowerCase();
+    if (!VALID_INTENTS.has(normalized)) {
+        throw new Error(`monetization_intent ${JSON.stringify(intent)} not in ${[...VALID_INTENTS].sort()}`);
+    }
+    return normalized;
+}
+/** Scan text for known IP terms (mirrors scripts/ip_risk.py). */
+export function detectIpTerms(text) {
+    if (!text)
+        return [];
+    const seen = new Set();
+    const hits = [];
+    for (const [category, terms] of Object.entries(CATEGORIES)) {
+        for (let i = 0; i < text.length; i += 1) {
+            for (const term of terms) {
+                if (!wordBoundaryMatch(text, i, term))
+                    continue;
+                const actual = text.slice(i, i + term.length);
+                const key = `${actual.toLowerCase()}\0${category}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                hits.push({ term: actual, category });
+            }
+        }
+    }
+    return hits;
+}
+export function isIpAdjacent(text) {
+    return detectIpTerms(text).length > 0;
+}
+export function ipRiskScopeItems(monetizationIntent) {
+    const intent = validateIntent(monetizationIntent);
+    const commercial = intent !== "personal";
+    const baseAcceptance = commercial
+        ? "Lawyer-confirmed wording before public release"
+        : "Reviewed by the project owner before any public release";
+    const assetAcceptance = commercial
+        ? "All third-party assets reach the app via official APIs only with a license that explicitly permits the planned use; no assets bundled in the repository or build artifacts; lawyer-confirmed before public release"
+        : "All third-party assets reach the app via official APIs only; no assets bundled in the repository or build artifacts";
+    const hostingAcceptance = commercial
+        ? "Hosting plan reviewed by counsel; written license terms cover the deployment region and audience; revenue model documented"
+        : "Self-hosted private use only; do not deploy publicly until a monetization decision is made and re-reviewed against this rule";
+    return [
+        {
+            title: "IP-risk: disclaimer stub on the app's front surface",
+            status: "pending",
+            narrative: {
+                Description: "Add a 'not affiliated with / not endorsed by' notice on the app's first user-visible surface (splash screen, landing page, or CLI banner).",
+                Acceptance: baseAcceptance,
+                Traces: "IP-1",
+            },
+        },
+        {
+            title: "IP-risk: API-only third-party asset access policy",
+            status: "pending",
+            narrative: {
+                Description: "Never bundle third-party IP assets (images, audio, video, text, card data, character likenesses) in the repository or build artifacts. Access only via official APIs that grant a license.",
+                Acceptance: assetAcceptance,
+                Traces: "IP-2",
+            },
+        },
+        {
+            title: "IP-risk: hosting policy gated on monetization intent",
+            status: "pending",
+            narrative: {
+                Description: "Document the hosting plan and gate it on the captured monetization intent. Self-hosted private use is the default; commercial hosting requires lawyer review.",
+                Acceptance: hostingAcceptance,
+                Traces: "IP-3",
+            },
+        },
+    ];
+}
+export function plainRiskSummary(hits, monetizationIntent) {
+    if (hits.length === 0)
+        return "";
+    const intent = validateIntent(monetizationIntent);
+    const grouped = new Map();
+    for (const hit of hits) {
+        const list = grouped.get(hit.category) ?? [];
+        list.push(hit.term);
+        grouped.set(hit.category, list);
+    }
+    const bullets = [];
+    for (const [category, terms] of grouped) {
+        const uniqueTerms = [...new Set(terms)].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        bullets.push(`- ${category}: ${uniqueTerms.join(", ")}`);
+    }
+    const header = "Heads up: your project description references third-party intellectual property (IP). This is a plain-English summary -- not legal advice.";
+    const detectionBlock = `Detected IP-adjacent terms:\n${bullets.join("\n")}`;
+    let intentBlock;
+    if (intent === "commercial") {
+        intentBlock =
+            "You said you intend to use this commercially (sell access, earn revenue, distribute to paying users, or run ads). Commercial use of someone else's IP without a written license is the high-risk case. You MUST consult a lawyer before shipping to paying users -- this is not optional output from this interview.";
+    }
+    else if (intent === "personal") {
+        intentBlock =
+            "You said this is a personal project (no monetization, private use, learning). Personal use is lower risk but not zero risk: if your project ever goes public, becomes monetized, or is shared widely, the risk profile changes and a lawyer review becomes worthwhile.";
+    }
+    else {
+        intentBlock =
+            "You did not choose between personal and commercial use. The interview MUST capture an explicit answer before generating the SPECIFICATION -- the legal-risk profile depends on the answer.";
+    }
+    const nextSteps = "Suggested next steps: (1) confirm whether your use is personal or commercial; (2) keep the disclaimer / API-only-asset / hosting scope items the SPECIFICATION will include; (3) for commercial intent, consult a lawyer before public release.";
+    return [header, detectionBlock, intentBlock, nextSteps].join("\n\n");
+}
+//# sourceMappingURL=ip-risk.js.map

package/dist/platform/linear-scan.d.ts

@@ -0,0 +1,36 @@
+/** ReDoS-safe linear scanners shared by platform parsers. */
+/** Return true when `ch` is ASCII word character [A-Za-z0-9_]. */
+export declare function isWordChar(ch: string): boolean;
+/** Case-insensitive compare of `text.slice(pos, pos+needle.length)` to `needle`. */
+export declare function matchAt(text: string, pos: number, needle: string): boolean;
+/** Find first case-insensitive occurrence of `needle` starting at `from`. */
+export declare function indexOfIgnoreCase(text: string, needle: string, from?: number): number;
+/** Word-boundary match for `term` at `pos` in `text` (ASCII heuristic). */
+export declare function wordBoundaryMatch(text: string, pos: number, term: string): boolean;
+/** Scan `text` for the first word-boundary occurrence of any `term`. */
+export declare function findFirstTerm(text: string, terms: readonly string[], from?: number): {
+    term: string;
+    index: number;
+} | null;
+/** Parse `<!-- deft:managed-section vN [attrs] -->` at `startIdx` (must point at '<'). */
+export declare function parseManagedOpenMarker(text: string, startIdx: number): {
+    end: number;
+    version: number;
+    attrsRaw: string;
+} | null;
+/** Find next managed-section open marker from `from`. */
+export declare function findManagedOpenMarker(text: string, from?: number): {
+    start: number;
+    version: number;
+    attrsRaw: string;
+    end: number;
+} | null;
+/** Match line against `^## [name]` without regex backtracking. */
+export declare function parseSectionHeader(line: string): string | null;
+/** Match line against `^### name` without regex. */
+export declare function parseSubsectionHeader(line: string): string | null;
+/** True when line starts a bullet entry (`-` or `*` with optional indent). */
+export declare function isEntryBulletLine(line: string): boolean;
+/** Extract all `(#NNN)` issue numbers from text via linear scan. */
+export declare function extractIssueNumbers(text: string): Set<string>;
+//# sourceMappingURL=linear-scan.d.ts.map

package/dist/platform/linear-scan.js

@@ -0,0 +1,174 @@
+/** ReDoS-safe linear scanners shared by platform parsers. */
+/** Return true when `ch` is ASCII word character [A-Za-z0-9_]. */
+export function isWordChar(ch) {
+    if (ch.length !== 1)
+        return false;
+    const code = ch.charCodeAt(0);
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) ||
+        code === 95);
+}
+/** Case-insensitive compare of `text.slice(pos, pos+needle.length)` to `needle`. */
+export function matchAt(text, pos, needle) {
+    if (pos + needle.length > text.length)
+        return false;
+    return text.slice(pos, pos + needle.length).toLowerCase() === needle.toLowerCase();
+}
+/** Find first case-insensitive occurrence of `needle` starting at `from`. */
+export function indexOfIgnoreCase(text, needle, from = 0) {
+    const lower = text.toLowerCase();
+    const nLower = needle.toLowerCase();
+    return lower.indexOf(nLower, from);
+}
+/** Word-boundary match for `term` at `pos` in `text` (ASCII heuristic). */
+export function wordBoundaryMatch(text, pos, term) {
+    if (!matchAt(text, pos, term))
+        return false;
+    const before = pos > 0 ? (text[pos - 1] ?? "") : "";
+    const after = pos + term.length < text.length ? (text[pos + term.length] ?? "") : "";
+    if (before && isWordChar(before))
+        return false;
+    if (after && isWordChar(after))
+        return false;
+    return true;
+}
+/** Scan `text` for the first word-boundary occurrence of any `term`. */
+export function findFirstTerm(text, terms, from = 0) {
+    let best = null;
+    for (const term of terms) {
+        let pos = from;
+        while (pos <= text.length - term.length) {
+            const idx = indexOfIgnoreCase(text, term, pos);
+            if (idx < 0)
+                break;
+            if (wordBoundaryMatch(text, idx, term)) {
+                if (best === null || idx < best.index) {
+                    best = { term: text.slice(idx, idx + term.length), index: idx };
+                }
+                break;
+            }
+            pos = idx + 1;
+        }
+    }
+    return best;
+}
+/** Parse `<!-- deft:managed-section vN [attrs] -->` at `startIdx` (must point at '<'). */
+export function parseManagedOpenMarker(text, startIdx) {
+    if (text.slice(startIdx, startIdx + 4) !== "<!--")
+        return null;
+    let i = startIdx + 4;
+    while (i < text.length && (text[i] === " " || text[i] === "\t"))
+        i += 1;
+    const marker = "deft:managed-section";
+    if (!matchAt(text, i, marker))
+        return null;
+    i += marker.length;
+    while (i < text.length && (text[i] === " " || text[i] === "\t"))
+        i += 1;
+    if (text[i] !== "v")
+        return null;
+    i += 1;
+    const versionChar = text[i];
+    if (versionChar !== "1" && versionChar !== "2" && versionChar !== "3")
+        return null;
+    const version = Number(versionChar);
+    i += 1;
+    const attrsStart = i;
+    while (i < text.length) {
+        if (text[i] === "-" && text[i + 1] === "-" && text[i + 2] === ">") {
+            const attrsRaw = text.slice(attrsStart, i).trim();
+            return { end: i + 3, version, attrsRaw };
+        }
+        i += 1;
+    }
+    return null;
+}
+/** Find next managed-section open marker from `from`. */
+export function findManagedOpenMarker(text, from = 0) {
+    let pos = from;
+    while (pos < text.length) {
+        const idx = text.indexOf("<!--", pos);
+        if (idx < 0)
+            return null;
+        const parsed = parseManagedOpenMarker(text, idx);
+        if (parsed !== null) {
+            return { start: idx, version: parsed.version, attrsRaw: parsed.attrsRaw, end: parsed.end };
+        }
+        pos = idx + 1;
+    }
+    return null;
+}
+/** Match line against `^## [name]` without regex backtracking. */
+export function parseSectionHeader(line) {
+    let i = 0;
+    while (i < line.length && line[i] === " ")
+        i += 1;
+    if (line.slice(i, i + 3) !== "## ")
+        return null;
+    i += 3;
+    if (line[i] !== "[")
+        return null;
+    i += 1;
+    const start = i;
+    while (i < line.length && line[i] !== "]")
+        i += 1;
+    if (i >= line.length)
+        return null;
+    return line.slice(start, i);
+}
+/** Match line against `^### name` without regex. */
+export function parseSubsectionHeader(line) {
+    let i = 0;
+    while (i < line.length && line[i] === " ")
+        i += 1;
+    if (line.slice(i, i + 4) !== "### ")
+        return null;
+    i += 4;
+    const start = i;
+    while (i < line.length && line[i] !== "\r" && line[i] !== "\n")
+        i += 1;
+    const name = line.slice(start, i).trim();
+    return name.length > 0 ? name : null;
+}
+/** True when line starts a bullet entry (`-` or `*` with optional indent). */
+export function isEntryBulletLine(line) {
+    let i = 0;
+    while (i < line.length && (line[i] === " " || line[i] === "\t"))
+        i += 1;
+    if (line[i] !== "-" && line[i] !== "*")
+        return false;
+    i += 1;
+    if (i >= line.length)
+        return false;
+    return line[i] === " " || line[i] === "\t";
+}
+/** Extract all `(#NNN)` issue numbers from text via linear scan. */
+export function extractIssueNumbers(text) {
+    const nums = new Set();
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] === "(" && text[i + 1] === "#") {
+            let j = i + 2;
+            let digits = "";
+            while (j < text.length) {
+                const ch = text[j] ?? "";
+                if (ch >= "0" && ch <= "9") {
+                    digits += ch;
+                    j += 1;
+                }
+                else {
+                    break;
+                }
+            }
+            if (digits.length > 0 && text[j] === ")") {
+                nums.add(digits);
+                i = j + 1;
+                continue;
+            }
+        }
+        i += 1;
+    }
+    return nums;
+}
+//# sourceMappingURL=linear-scan.js.map

package/dist/platform/platform-capabilities.d.ts

@@ -0,0 +1,45 @@
+export interface UidMapEntry {
+    readonly insideId: number;
+    readonly outsideId: number;
+    readonly length: number;
+}
+export interface OwnershipFacts {
+    readonly path: string;
+    readonly uid: number;
+    readonly gid: number;
+    readonly interpretedAsSandboxView: boolean;
+}
+export interface RuntimeCapabilityReport {
+    readonly runtimeMode: string;
+    readonly identityKind: string;
+    readonly effectiveUid: number | null;
+    readonly effectiveUsername: string | null;
+    readonly uidMap: readonly UidMapEntry[];
+    readonly cursorOrigUid: number | null;
+    readonly cursorOrigGid: number | null;
+    readonly sandboxUidRemap: boolean;
+    readonly ownership: OwnershipFacts | null;
+    readonly signals: Readonly<Record<string, string>>;
+}
+export declare function readUidMap(path: string): readonly UidMapEntry[];
+export declare function detectSandboxUidRemap(uidMap: readonly UidMapEntry[], options: {
+    effectiveUid: number | null;
+    cursorOrigUid: number | null;
+}): boolean;
+export declare function classifyIdentityKind(options: {
+    effectiveUid: number | null;
+    sandboxUidRemap: boolean;
+}): string;
+export declare function classifyRuntimeMode(environ: Readonly<Record<string, string>>, sandboxUidRemap: boolean): string;
+export interface ProbeRuntimeOptions {
+    readonly environ?: Readonly<Record<string, string>>;
+    readonly uidMapPath?: string;
+    readonly cwd?: string;
+    readonly effectiveUidOverride?: number | null;
+    readonly effectiveUsername?: string | null;
+    readonly getuid?: () => number;
+}
+export declare function probeRuntimeCapabilities(options?: ProbeRuntimeOptions): RuntimeCapabilityReport;
+export declare function getPlatformCapabilities(options?: ProbeRuntimeOptions): RuntimeCapabilityReport;
+export declare function reportToDict(report: RuntimeCapabilityReport): Record<string, unknown>;
+//# sourceMappingURL=platform-capabilities.d.ts.map

package/dist/platform/platform-capabilities.js

@@ -0,0 +1,190 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { userInfo } from "node:os";
+import { IDENTITY_LOCAL_USER, IDENTITY_REAL_ROOT, IDENTITY_SANDBOX_REMAPPED_LOCAL_USER, IDENTITY_UNKNOWN, RUNTIME_MODE_CLOUD_HEADLESS, RUNTIME_MODE_CURSOR_NATIVE_SANDBOX, RUNTIME_MODE_LOCAL_UNSANDBOXED, } from "./constants.js";
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+const CURSOR_SIGNAL_VARS = [
+    "CURSOR_SANDBOX",
+    "CURSOR_SANDBOX_LANDLOCK_STATUS",
+    "CURSOR_ORIG_UID",
+    "CURSOR_ORIG_GID",
+    "CURSOR_AGENT",
+    "CURSOR_COMPOSER",
+];
+const CLOUD_SIGNAL_VARS = [
+    "CURSOR_AGENT",
+    "GROK_BUILD",
+    "DEFT_AGENT_RUNTIME",
+    "CI",
+    "GITHUB_ACTIONS",
+    "BUILDKITE",
+];
+function envTruthy(environ, name) {
+    return TRUTHY.has((environ[name] ?? "").trim().toLowerCase());
+}
+function parseIntValue(value) {
+    if (value === undefined)
+        return null;
+    const text = value.trim();
+    if (!text)
+        return null;
+    const n = Number.parseInt(text, 10);
+    return Number.isNaN(n) ? null : n;
+}
+export function readUidMap(path) {
+    if (!existsSync(path))
+        return [];
+    const entries = [];
+    for (const rawLine of readFileSync(path, "utf8").split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const parts = line.split(/\s+/);
+        if (parts.length !== 3)
+            continue;
+        const insideId = Number.parseInt(parts[0] ?? "", 10);
+        const outsideId = Number.parseInt(parts[1] ?? "", 10);
+        const length = Number.parseInt(parts[2] ?? "", 10);
+        if (Number.isNaN(insideId) || Number.isNaN(outsideId) || Number.isNaN(length))
+            continue;
+        entries.push({ insideId, outsideId, length });
+    }
+    return entries;
+}
+export function detectSandboxUidRemap(uidMap, options) {
+    if (options.effectiveUid !== 0)
+        return false;
+    if (options.cursorOrigUid === null)
+        return false;
+    return uidMap.some((entry) => entry.insideId === 0 && entry.outsideId === options.cursorOrigUid);
+}
+export function classifyIdentityKind(options) {
+    if (options.effectiveUid === null)
+        return IDENTITY_UNKNOWN;
+    if (options.effectiveUid === 0) {
+        return options.sandboxUidRemap ? IDENTITY_SANDBOX_REMAPPED_LOCAL_USER : IDENTITY_REAL_ROOT;
+    }
+    return IDENTITY_LOCAL_USER;
+}
+function isCloudHeadless(environ) {
+    if (envTruthy(environ, "CURSOR_AGENT"))
+        return true;
+    if (envTruthy(environ, "GROK_BUILD"))
+        return true;
+    const runtime = (environ.DEFT_AGENT_RUNTIME ?? "").trim().toLowerCase();
+    if (runtime === "grok-build" || runtime === "cloud" || runtime === "headless")
+        return true;
+    if (envTruthy(environ, "GITHUB_ACTIONS") || envTruthy(environ, "BUILDKITE"))
+        return true;
+    return envTruthy(environ, "CI") && !envTruthy(environ, "CURSOR_COMPOSER");
+}
+function isCursorNativeSandbox(environ, sandboxUidRemap) {
+    if (sandboxUidRemap)
+        return true;
+    if (envTruthy(environ, "CURSOR_SANDBOX"))
+        return true;
+    return Boolean((environ.CURSOR_SANDBOX_LANDLOCK_STATUS ?? "").trim());
+}
+export function classifyRuntimeMode(environ, sandboxUidRemap) {
+    if (isCloudHeadless(environ))
+        return RUNTIME_MODE_CLOUD_HEADLESS;
+    if (isCursorNativeSandbox(environ, sandboxUidRemap))
+        return RUNTIME_MODE_CURSOR_NATIVE_SANDBOX;
+    return RUNTIME_MODE_LOCAL_UNSANDBOXED;
+}
+function readOwnership(path, sandboxUidRemap) {
+    try {
+        const stat = statSync(path);
+        return {
+            path,
+            uid: stat.uid,
+            gid: stat.gid,
+            interpretedAsSandboxView: sandboxUidRemap,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function collectSignals(environ) {
+    const names = [...new Set([...CURSOR_SIGNAL_VARS, ...CLOUD_SIGNAL_VARS])].sort();
+    const out = {};
+    for (const name of names) {
+        if (name in environ)
+            out[name] = environ[name] ?? "";
+    }
+    return out;
+}
+export function probeRuntimeCapabilities(options = {}) {
+    const env = options.environ === undefined
+        ? { ...process.env }
+        : { ...options.environ };
+    let effectiveUid;
+    if (options.effectiveUidOverride !== undefined) {
+        effectiveUid = options.effectiveUidOverride;
+    }
+    else if (options.getuid) {
+        effectiveUid = options.getuid();
+    }
+    else {
+        effectiveUid = null;
+    }
+    let effectiveUsername = options.effectiveUsername ?? env.USER ?? env.USERNAME ?? null;
+    if (!effectiveUsername) {
+        try {
+            effectiveUsername = userInfo().username;
+        }
+        catch {
+            effectiveUsername = null;
+        }
+    }
+    const cursorOrigUid = parseIntValue(env.CURSOR_ORIG_UID);
+    const cursorOrigGid = parseIntValue(env.CURSOR_ORIG_GID);
+    const uidMapFile = options.uidMapPath ?? "/proc/self/uid_map";
+    const uidMap = readUidMap(uidMapFile);
+    const sandboxUidRemap = detectSandboxUidRemap(uidMap, { effectiveUid, cursorOrigUid });
+    const identityKind = classifyIdentityKind({ effectiveUid, sandboxUidRemap });
+    const runtimeMode = classifyRuntimeMode(env, sandboxUidRemap);
+    const cwdPath = options.cwd ?? process.cwd();
+    const ownership = readOwnership(cwdPath, sandboxUidRemap);
+    return {
+        runtimeMode,
+        identityKind,
+        effectiveUid,
+        effectiveUsername,
+        uidMap,
+        cursorOrigUid,
+        cursorOrigGid,
+        sandboxUidRemap,
+        ownership,
+        signals: collectSignals(env),
+    };
+}
+export function getPlatformCapabilities(options = {}) {
+    return probeRuntimeCapabilities(options);
+}
+export function reportToDict(report) {
+    return {
+        runtime_mode: report.runtimeMode,
+        identity_kind: report.identityKind,
+        effective_uid: report.effectiveUid,
+        effective_username: report.effectiveUsername,
+        uid_map: report.uidMap.map((e) => ({
+            inside_id: e.insideId,
+            outside_id: e.outsideId,
+            length: e.length,
+        })),
+        cursor_orig_uid: report.cursorOrigUid,
+        cursor_orig_gid: report.cursorOrigGid,
+        sandbox_uid_remap: report.sandboxUidRemap,
+        ownership: report.ownership
+            ? {
+                path: report.ownership.path,
+                uid: report.ownership.uid,
+                gid: report.ownership.gid,
+                interpreted_as_sandbox_view: report.ownership.interpretedAsSandboxView,
+            }
+            : null,
+        signals: report.signals,
+    };
+}
+//# sourceMappingURL=platform-capabilities.js.map