@tsonic/cli 0.0.63 → 0.0.64

package/dist/aikya/bindings.js

@@ -0,0 +1,777 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { resolvePackageRoot } from "../commands/add-common.js";
+const AIKYA_DIAGNOSTIC = {
+    invalidSchema: "TSN8A01",
+    unresolvedRuntime: "TSN8A02",
+    conflictingRuntime: "TSN8A03",
+    missingBindingsRoot: "TSN8A04",
+    missingRuntimeMapping: "TSN8A05",
+};
+const normalizeId = (id) => id.trim().toLowerCase();
+const errorWithCode = (code, message) => {
+    return { ok: false, error: `${code}: ${message}` };
+};
+const isSurfaceMode = (value) => value === "clr" || value === "js" || value === "nodejs";
+const readJsonObject = (path, parseErrorCode) => {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed === null ||
+            typeof parsed !== "object" ||
+            Array.isArray(parsed)) {
+            return errorWithCode(parseErrorCode, `Expected JSON object at ${path}`);
+        }
+        return { ok: true, value: parsed };
+    }
+    catch (error) {
+        return errorWithCode(parseErrorCode, `Failed to parse JSON at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const parseFrameworkReference = (value, path) => {
+    if (typeof value === "string" && value.trim().length > 0) {
+        return { ok: true, value: value.trim() };
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path} must be a string or { id, types? }`);
+    }
+    const id = value.id;
+    const types = value.types;
+    if (typeof id !== "string" || id.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.id must be a non-empty string`);
+    }
+    if (types !== undefined &&
+        types !== false &&
+        (typeof types !== "string" || types.trim().length === 0)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.types must be a non-empty string or false`);
+    }
+    return {
+        ok: true,
+        value: types === undefined ? { id: id.trim() } : { id: id.trim(), types },
+    };
+};
+const parsePackageReference = (value, path) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path} must be { id, version, types? }`);
+    }
+    const id = value.id;
+    const version = value.version;
+    const types = value.types;
+    if (typeof id !== "string" || id.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.id must be a non-empty string`);
+    }
+    if (typeof version !== "string" || version.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.version must be a non-empty string`);
+    }
+    if (types !== undefined &&
+        types !== false &&
+        (typeof types !== "string" || types.trim().length === 0)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.types must be a non-empty string or false`);
+    }
+    return {
+        ok: true,
+        value: {
+            id: id.trim(),
+            version: version.trim(),
+            ...(types === undefined ? {} : { types }),
+        },
+    };
+};
+const parseManifestDotnet = (value, path) => {
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path} must be an object`);
+    }
+    const raw = value;
+    let frameworkReferences;
+    if (raw.frameworkReferences !== undefined) {
+        if (!Array.isArray(raw.frameworkReferences)) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.frameworkReferences must be an array`);
+        }
+        frameworkReferences = [];
+        for (const [index, entry] of raw.frameworkReferences.entries()) {
+            const parsed = parseFrameworkReference(entry, `${path}.frameworkReferences[${index}]`);
+            if (!parsed.ok)
+                return parsed;
+            frameworkReferences.push(parsed.value);
+        }
+    }
+    let packageReferences;
+    if (raw.packageReferences !== undefined) {
+        if (!Array.isArray(raw.packageReferences)) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.packageReferences must be an array`);
+        }
+        packageReferences = [];
+        for (const [index, entry] of raw.packageReferences.entries()) {
+            const parsed = parsePackageReference(entry, `${path}.packageReferences[${index}]`);
+            if (!parsed.ok)
+                return parsed;
+            packageReferences.push(parsed.value);
+        }
+    }
+    let msbuildProperties;
+    if (raw.msbuildProperties !== undefined) {
+        if (raw.msbuildProperties === null ||
+            typeof raw.msbuildProperties !== "object" ||
+            Array.isArray(raw.msbuildProperties)) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.msbuildProperties must be an object`);
+        }
+        msbuildProperties = {};
+        for (const [key, value] of Object.entries(raw.msbuildProperties)) {
+            if (typeof value !== "string") {
+                return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `${path}.msbuildProperties.${key} must be a string`);
+            }
+            msbuildProperties[key] = value;
+        }
+    }
+    const hasFramework = (frameworkReferences?.length ?? 0) > 0;
+    const hasPackage = (packageReferences?.length ?? 0) > 0;
+    const hasMsbuild = Object.keys(msbuildProperties ?? {}).length > 0;
+    if (!hasFramework && !hasPackage && !hasMsbuild) {
+        return { ok: true, value: undefined };
+    }
+    return {
+        ok: true,
+        value: {
+            frameworkReferences,
+            packageReferences,
+            msbuildProperties,
+        },
+    };
+};
+const sortFrameworkReferences = (refs) => [...refs].sort((a, b) => {
+    const idA = typeof a === "string" ? a : a.id;
+    const idB = typeof b === "string" ? b : b.id;
+    return normalizeId(idA).localeCompare(normalizeId(idB));
+});
+const sortPackageReferences = (refs) => [...refs].sort((a, b) => {
+    const byId = normalizeId(a.id).localeCompare(normalizeId(b.id));
+    if (byId !== 0)
+        return byId;
+    return a.version.localeCompare(b.version);
+});
+const sortMsbuildProperties = (props) => {
+    const out = {};
+    const keys = Object.keys(props).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+        const value = props[key];
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+};
+const canonicalizeManifestDotnet = (dotnet) => {
+    if (!dotnet)
+        return undefined;
+    const frameworkReferences = sortFrameworkReferences((dotnet.frameworkReferences ?? []));
+    const packageReferences = sortPackageReferences((dotnet.packageReferences ?? []));
+    const msbuildProperties = sortMsbuildProperties((dotnet.msbuildProperties ?? {}));
+    const hasMsbuild = Object.keys(msbuildProperties).length > 0;
+    const hasFramework = frameworkReferences.length > 0;
+    const hasPackage = packageReferences.length > 0;
+    if (!hasMsbuild && !hasFramework && !hasPackage) {
+        return undefined;
+    }
+    return {
+        frameworkReferences: hasFramework ? frameworkReferences : undefined,
+        packageReferences: hasPackage ? packageReferences : undefined,
+        msbuildProperties: hasMsbuild ? msbuildProperties : undefined,
+    };
+};
+export const mergeFrameworkReferences = (existing, incoming, conflictCode = undefined) => {
+    const out = [...existing];
+    const byId = new Map();
+    for (const ref of out) {
+        const id = typeof ref === "string" ? ref : ref.id;
+        byId.set(normalizeId(id), ref);
+    }
+    for (const ref of incoming) {
+        const id = typeof ref === "string" ? ref : ref.id;
+        const key = normalizeId(id);
+        const current = byId.get(key);
+        if (!current) {
+            out.push(ref);
+            byId.set(key, ref);
+            continue;
+        }
+        const currentTypes = typeof current === "string" ? undefined : current.types;
+        const nextTypes = typeof ref === "string" ? undefined : ref.types;
+        if (nextTypes !== undefined &&
+            currentTypes !== undefined &&
+            currentTypes !== nextTypes) {
+            const msg = `Conflicting framework types mapping for '${id}'.\n` +
+                `Existing: ${String(currentTypes)}\n` +
+                `Incoming: ${String(nextTypes)}\n` +
+                `Refusing to merge automatically (airplane-grade).`;
+            return conflictCode
+                ? errorWithCode(conflictCode, msg)
+                : { ok: false, error: msg };
+        }
+        if (typeof current === "string" && typeof ref !== "string") {
+            const idx = out.findIndex((x) => normalizeId(typeof x === "string" ? x : x.id) === normalizeId(current));
+            if (idx >= 0)
+                out[idx] = { id: current, types: ref.types };
+            byId.set(key, out[idx]);
+        }
+    }
+    return { ok: true, value: sortFrameworkReferences(out) };
+};
+export const mergePackageReferences = (existing, incoming, conflictCode = undefined) => {
+    const out = [...existing];
+    const byId = new Map();
+    for (const p of out)
+        byId.set(normalizeId(p.id), p);
+    for (const p of incoming) {
+        const key = normalizeId(p.id);
+        const current = byId.get(key);
+        if (!current) {
+            out.push(p);
+            byId.set(key, p);
+            continue;
+        }
+        if (current.version !== p.version) {
+            const msg = `NuGet package already present with a different version: ${current.id} ${current.version}\n` +
+                `Incoming requested: ${p.id} ${p.version}\n` +
+                `Refusing to merge automatically (airplane-grade).`;
+            return conflictCode
+                ? errorWithCode(conflictCode, msg)
+                : { ok: false, error: msg };
+        }
+        if (p.types !== undefined &&
+            current.types !== undefined &&
+            current.types !== p.types) {
+            const msg = `NuGet package already present with a different types mapping:\n` +
+                `- ${current.id} ${current.version}\n` +
+                `- existing: ${String(current.types)}\n` +
+                `- incoming: ${String(p.types)}\n` +
+                `Refusing to merge automatically (airplane-grade).`;
+            return conflictCode
+                ? errorWithCode(conflictCode, msg)
+                : { ok: false, error: msg };
+        }
+        if (current.types === undefined && p.types !== undefined) {
+            const idx = out.findIndex((x) => normalizeId(x.id) === key);
+            if (idx >= 0)
+                out[idx] = { ...current, types: p.types };
+            byId.set(key, out[idx]);
+        }
+    }
+    return { ok: true, value: sortPackageReferences(out) };
+};
+export const mergeMsbuildProperties = (existing, incoming, conflictCode = undefined) => {
+    const out = { ...existing };
+    for (const [k, v] of Object.entries(incoming)) {
+        const current = out[k];
+        if (current !== undefined && current !== v) {
+            const msg = `Conflicting msbuildProperties for key '${k}'.\n` +
+                `Existing: ${current}\n` +
+                `Incoming: ${v}\n` +
+                `Refusing to merge automatically (airplane-grade).`;
+            return conflictCode
+                ? errorWithCode(conflictCode, msg)
+                : { ok: false, error: msg };
+        }
+        out[k] = v;
+    }
+    return { ok: true, value: sortMsbuildProperties(out) };
+};
+const collectNugetDependencies = (dotnet, testDotnet) => {
+    const dependencies = [];
+    const addFrameworkRefs = (refs, source) => {
+        for (const ref of refs ?? []) {
+            const id = typeof ref === "string" ? ref : ref.id;
+            dependencies.push({ source, id });
+        }
+    };
+    const addPackageRefs = (refs, source) => {
+        for (const ref of refs ?? []) {
+            dependencies.push({ source, id: ref.id, version: ref.version });
+        }
+    };
+    addFrameworkRefs(dotnet?.frameworkReferences, "dotnet.framework");
+    addPackageRefs(dotnet?.packageReferences, "dotnet.package");
+    addFrameworkRefs(testDotnet?.frameworkReferences, "testDotnet.framework");
+    addPackageRefs(testDotnet?.packageReferences, "testDotnet.package");
+    return dependencies.sort((a, b) => {
+        const bySource = a.source.localeCompare(b.source);
+        if (bySource !== 0)
+            return bySource;
+        const byId = normalizeId(a.id).localeCompare(normalizeId(b.id));
+        if (byId !== 0)
+            return byId;
+        return (a.version ?? "").localeCompare(b.version ?? "");
+    });
+};
+const collectRuntimePackagesFromLegacy = (packageName, runtimePackages, dotnet, testDotnet) => {
+    const set = new Set();
+    set.add(packageName);
+    for (const pkg of runtimePackages ?? []) {
+        if (pkg.trim())
+            set.add(pkg.trim());
+    }
+    const collectTypesPackage = (refs) => {
+        for (const ref of refs) {
+            if (typeof ref === "string")
+                continue;
+            if (typeof ref.types === "string" && ref.types.trim())
+                set.add(ref.types.trim());
+        }
+    };
+    collectTypesPackage((dotnet?.frameworkReferences ?? []));
+    collectTypesPackage((dotnet?.packageReferences ?? []));
+    collectTypesPackage((testDotnet?.frameworkReferences ??
+        []));
+    collectTypesPackage((testDotnet?.packageReferences ?? []));
+    return [...set].sort((a, b) => normalizeId(a).localeCompare(normalizeId(b)));
+};
+const parseAikyaProducer = (value) => {
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, "producer must be an object");
+    }
+    const tool = value.tool;
+    const version = value.version;
+    const mode = value.mode;
+    if (tool !== "tsonic" && tool !== "tsbindgen") {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `producer.tool must be "tsonic" or "tsbindgen"`);
+    }
+    if (typeof version !== "string" || version.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, "producer.version must be a non-empty string");
+    }
+    if (mode !== "aikya-firstparty" && mode !== "external-clr") {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `producer.mode must be "aikya-firstparty" or "external-clr"`);
+    }
+    return {
+        ok: true,
+        value: {
+            tool,
+            version: version.trim(),
+            mode,
+        },
+    };
+};
+const parseRuntimeNugetPackages = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.missingRuntimeMapping, "runtime.nugetPackages must be a non-empty array");
+    }
+    const out = [];
+    for (const [index, entry] of value.entries()) {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.unresolvedRuntime, `runtime.nugetPackages[${index}] must be { id, version }`);
+        }
+        const id = entry.id;
+        const version = entry.version;
+        if (typeof id !== "string" || id.trim().length === 0) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.unresolvedRuntime, `runtime.nugetPackages[${index}].id must be a non-empty string`);
+        }
+        if (typeof version !== "string" || version.trim().length === 0) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.unresolvedRuntime, `runtime.nugetPackages[${index}].version must be a non-empty string`);
+        }
+        out.push({ id: id.trim(), version: version.trim() });
+    }
+    return { ok: true, value: out };
+};
+const parseRuntimeFrameworkReferences = (value) => {
+    if (value === undefined)
+        return { ok: true, value: [] };
+    if (!Array.isArray(value)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, "runtime.frameworkReferences must be an array when present");
+    }
+    const refs = [];
+    for (const [index, entry] of value.entries()) {
+        const parsed = parseFrameworkReference(entry, `runtime.frameworkReferences[${index}]`);
+        if (!parsed.ok)
+            return parsed;
+        refs.push(parsed.value);
+    }
+    return { ok: true, value: refs };
+};
+const parseRuntimePackages = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((x) => typeof x === "string")
+        .map((x) => x.trim())
+        .filter((x) => x.length > 0)
+        .sort((a, b) => normalizeId(a).localeCompare(normalizeId(b)));
+};
+const resolveFromAikyaManifest = (packageRoot, packageName, packageVersion) => {
+    const path = join(packageRoot, "tsonic", "package-manifest.json");
+    if (!existsSync(path))
+        return { ok: true, value: null };
+    const parsed = readJsonObject(path, AIKYA_DIAGNOSTIC.invalidSchema);
+    if (!parsed.ok)
+        return parsed;
+    const manifest = parsed.value;
+    const schemaVersion = manifest.schemaVersion;
+    if (schemaVersion !== 1) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `schemaVersion must be 1 at ${path}`);
+    }
+    const kind = manifest.kind;
+    if (kind !== "tsonic-library") {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `kind must be "tsonic-library" at ${path}`);
+    }
+    const npmPackage = manifest.npmPackage;
+    if (typeof npmPackage !== "string" || npmPackage.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `npmPackage must be a non-empty string at ${path}`);
+    }
+    if (normalizeId(npmPackage) !== normalizeId(packageName)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `npmPackage mismatch in ${path}. Installed: ${packageName}, Manifest: ${npmPackage}`);
+    }
+    const npmVersion = manifest.npmVersion;
+    if (typeof npmVersion !== "string" || npmVersion.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `npmVersion must be a non-empty string at ${path}`);
+    }
+    if (npmVersion.trim() !== packageVersion) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `npmVersion mismatch in ${path}. Installed: ${packageVersion}, Manifest: ${npmVersion}`);
+    }
+    const typing = manifest.typing;
+    if (typing === null || typeof typing !== "object" || Array.isArray(typing)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `typing must be an object at ${path}`);
+    }
+    const bindingsRoot = typing
+        .bindingsRoot;
+    if (typeof bindingsRoot !== "string" || bindingsRoot.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `typing.bindingsRoot must be a non-empty string at ${path}`);
+    }
+    const bindingsRootPath = join(packageRoot, bindingsRoot);
+    if (!existsSync(bindingsRootPath)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.missingBindingsRoot, `typing.bindingsRoot does not exist: ${bindingsRootPath}`);
+    }
+    const runtime = manifest.runtime;
+    if (runtime === null ||
+        typeof runtime !== "object" ||
+        Array.isArray(runtime)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.missingRuntimeMapping, `runtime must be an object at ${path}`);
+    }
+    const runtimeNuget = parseRuntimeNugetPackages(runtime.nugetPackages);
+    if (!runtimeNuget.ok)
+        return runtimeNuget;
+    const runtimeFramework = parseRuntimeFrameworkReferences(runtime.frameworkReferences);
+    if (!runtimeFramework.ok)
+        return runtimeFramework;
+    const runtimePackages = parseRuntimePackages(runtime.runtimePackages);
+    const producer = parseAikyaProducer(manifest.producer);
+    if (!producer.ok)
+        return producer;
+    const dotnetParsed = parseManifestDotnet(manifest.dotnet, "dotnet");
+    if (!dotnetParsed.ok)
+        return dotnetParsed;
+    const testDotnetParsed = parseManifestDotnet(manifest.testDotnet, "testDotnet");
+    if (!testDotnetParsed.ok)
+        return testDotnetParsed;
+    const mergedDotnetPackages = mergePackageReferences((dotnetParsed.value?.packageReferences ?? []), runtimeNuget.value, AIKYA_DIAGNOSTIC.conflictingRuntime);
+    if (!mergedDotnetPackages.ok)
+        return mergedDotnetPackages;
+    const mergedDotnetFramework = mergeFrameworkReferences((dotnetParsed.value?.frameworkReferences ??
+        []), runtimeFramework.value, AIKYA_DIAGNOSTIC.conflictingRuntime);
+    if (!mergedDotnetFramework.ok)
+        return mergedDotnetFramework;
+    const dotnet = canonicalizeManifestDotnet({
+        frameworkReferences: mergedDotnetFramework.value,
+        packageReferences: mergedDotnetPackages.value,
+        msbuildProperties: dotnetParsed.value?.msbuildProperties,
+    });
+    const testDotnet = canonicalizeManifestDotnet(testDotnetParsed.value);
+    const runtimeSet = new Set();
+    runtimeSet.add(packageName);
+    for (const pkg of runtimePackages)
+        runtimeSet.add(pkg);
+    return {
+        ok: true,
+        value: {
+            bindingVersion: 1,
+            sourceManifest: "aikya",
+            packageName,
+            packageVersion,
+            surfaceMode: "clr",
+            bindingsRoot,
+            runtimePackages: [...runtimeSet].sort((a, b) => normalizeId(a).localeCompare(normalizeId(b))),
+            producer: producer.value,
+            dotnet,
+            testDotnet,
+            nugetDependencies: collectNugetDependencies(dotnet, testDotnet),
+        },
+    };
+};
+const resolveFromLegacyBindingsManifest = (packageRoot, packageName, packageVersion) => {
+    const manifestPath = join(packageRoot, "tsonic.bindings.json");
+    if (!existsSync(manifestPath))
+        return { ok: true, value: null };
+    const parsed = readJsonObject(manifestPath, AIKYA_DIAGNOSTIC.invalidSchema);
+    if (!parsed.ok)
+        return parsed;
+    const manifest = parsed.value;
+    const bindingVersion = manifest.bindingVersion;
+    if (bindingVersion !== undefined && bindingVersion !== 1) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `Unsupported tsonic.bindings.json bindingVersion: ${String(bindingVersion)}`);
+    }
+    const manifestPackageName = manifest.packageName;
+    if (manifestPackageName !== undefined) {
+        if (typeof manifestPackageName !== "string" ||
+            normalizeId(manifestPackageName) !== normalizeId(packageName)) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `tsonic.bindings.json packageName mismatch. Installed: ${packageName}, Manifest: ${String(manifestPackageName)}`);
+        }
+    }
+    const manifestPackageVersion = manifest.packageVersion;
+    if (manifestPackageVersion !== undefined) {
+        if (typeof manifestPackageVersion !== "string" ||
+            manifestPackageVersion !== packageVersion) {
+            return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `tsonic.bindings.json packageVersion mismatch. Installed: ${packageVersion}, Manifest: ${String(manifestPackageVersion)}`);
+        }
+    }
+    const surfaceModeRaw = manifest.surfaceMode;
+    if (surfaceModeRaw !== undefined && !isSurfaceMode(surfaceModeRaw)) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `Invalid tsonic.bindings.json surfaceMode: ${String(surfaceModeRaw)}`);
+    }
+    const surfaceMode = surfaceModeRaw ?? "clr";
+    const dotnetParsed = parseManifestDotnet(manifest.dotnet, "dotnet");
+    if (!dotnetParsed.ok)
+        return dotnetParsed;
+    const testDotnetParsed = parseManifestDotnet(manifest.testDotnet, "testDotnet");
+    if (!testDotnetParsed.ok)
+        return testDotnetParsed;
+    const dotnet = canonicalizeManifestDotnet(dotnetParsed.value);
+    const testDotnet = canonicalizeManifestDotnet(testDotnetParsed.value);
+    const runtimePackages = Array.isArray(manifest.runtimePackages)
+        ? manifest.runtimePackages.filter((x) => typeof x === "string")
+        : undefined;
+    return {
+        ok: true,
+        value: {
+            bindingVersion: 1,
+            sourceManifest: "legacy",
+            packageName,
+            packageVersion,
+            surfaceMode,
+            assemblyName: typeof manifest.assemblyName === "string"
+                ? manifest.assemblyName
+                : undefined,
+            assemblyVersion: typeof manifest.assemblyVersion === "string"
+                ? manifest.assemblyVersion
+                : undefined,
+            targetFramework: typeof manifest.targetFramework === "string"
+                ? manifest.targetFramework
+                : undefined,
+            runtimePackages: collectRuntimePackagesFromLegacy(packageName, runtimePackages, dotnet, testDotnet),
+            dotnet,
+            testDotnet,
+            nugetDependencies: collectNugetDependencies(dotnet, testDotnet),
+        },
+    };
+};
+const readInstalledPackageInfo = (packageRoot) => {
+    const packageJsonPath = join(packageRoot, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        return {
+            ok: false,
+            error: `package.json not found for installed npm package: ${packageRoot}`,
+        };
+    }
+    const parsed = readJsonObject(packageJsonPath, AIKYA_DIAGNOSTIC.invalidSchema);
+    if (!parsed.ok)
+        return parsed;
+    const name = parsed.value.name;
+    const version = parsed.value.version;
+    if (typeof name !== "string" || name.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `Invalid package.json (missing name): ${packageJsonPath}`);
+    }
+    if (typeof version !== "string" || version.trim().length === 0) {
+        return errorWithCode(AIKYA_DIAGNOSTIC.invalidSchema, `Invalid package.json (missing version): ${packageJsonPath}`);
+    }
+    return { ok: true, value: { name: name.trim(), version: version.trim() } };
+};
+export const resolveInstalledPackageBindingsManifest = (packageRoot) => {
+    const info = readInstalledPackageInfo(packageRoot);
+    if (!info.ok)
+        return info;
+    const aikya = resolveFromAikyaManifest(packageRoot, info.value.name, info.value.version);
+    if (!aikya.ok)
+        return aikya;
+    if (aikya.value)
+        return aikya;
+    return resolveFromLegacyBindingsManifest(packageRoot, info.value.name, info.value.version);
+};
+const collectDependencyNames = (value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return [];
+    }
+    return Object.keys(value);
+};
+const listWorkspaceDependencyNames = (workspaceRoot) => {
+    const packageJsonPath = join(workspaceRoot, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        return { ok: true, value: [] };
+    }
+    const parsed = readJsonObject(packageJsonPath, AIKYA_DIAGNOSTIC.invalidSchema);
+    if (!parsed.ok)
+        return parsed;
+    const dependencies = parsed.value.dependencies;
+    const devDependencies = parsed.value.devDependencies;
+    const optionalDependencies = parsed.value.optionalDependencies;
+    const names = new Set();
+    for (const name of collectDependencyNames(dependencies))
+        names.add(name);
+    for (const name of collectDependencyNames(devDependencies))
+        names.add(name);
+    for (const name of collectDependencyNames(optionalDependencies))
+        names.add(name);
+    return {
+        ok: true,
+        value: [...names].sort((a, b) => normalizeId(a).localeCompare(normalizeId(b))),
+    };
+};
+const resolveInstalledPackageRootFrom = (fromDir, dependencyName) => {
+    try {
+        const req = createRequire(join(fromDir, "package.json"));
+        const packageJsonPath = req.resolve(`${dependencyName}/package.json`);
+        return dirname(packageJsonPath);
+    }
+    catch {
+        return null;
+    }
+};
+const readInstalledPackageDependencyNames = (packageRoot) => {
+    const packageJsonPath = join(packageRoot, "package.json");
+    const parsed = readJsonObject(packageJsonPath, AIKYA_DIAGNOSTIC.invalidSchema);
+    if (!parsed.ok)
+        return parsed;
+    const dependencies = parsed.value.dependencies;
+    const optionalDependencies = parsed.value.optionalDependencies;
+    const peerDependencies = parsed.value.peerDependencies;
+    const names = new Set();
+    for (const name of collectDependencyNames(dependencies))
+        names.add(name);
+    for (const name of collectDependencyNames(optionalDependencies))
+        names.add(name);
+    for (const name of collectDependencyNames(peerDependencies))
+        names.add(name);
+    return {
+        ok: true,
+        value: [...names].sort((a, b) => normalizeId(a).localeCompare(normalizeId(b))),
+    };
+};
+export const discoverWorkspaceBindingsManifests = (workspaceRoot) => {
+    const rootDeps = listWorkspaceDependencyNames(workspaceRoot);
+    if (!rootDeps.ok)
+        return rootDeps;
+    const queue = rootDeps.value.map((dependencyName) => ({
+        dependencyName,
+        fromDir: workspaceRoot,
+        rootDependency: true,
+    }));
+    const seenPackageRoots = new Set();
+    const out = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current)
+            break;
+        let resolvedRoot = null;
+        let rootResolutionError;
+        if (current.fromDir === workspaceRoot) {
+            const rootResolved = resolvePackageRoot(workspaceRoot, current.dependencyName);
+            if (rootResolved.ok) {
+                resolvedRoot = rootResolved.value;
+            }
+            else {
+                rootResolutionError = rootResolved.error;
+            }
+        }
+        else {
+            resolvedRoot = resolveInstalledPackageRootFrom(current.fromDir, current.dependencyName);
+        }
+        if (!resolvedRoot) {
+            if (current.rootDependency) {
+                return errorWithCode(AIKYA_DIAGNOSTIC.unresolvedRuntime, `Unable to resolve workspace dependency '${current.dependencyName}' from node_modules.` +
+                    (rootResolutionError ? `\n${rootResolutionError}` : ""));
+            }
+            continue;
+        }
+        const packageRoot = resolvedRoot;
+        if (seenPackageRoots.has(packageRoot))
+            continue;
+        seenPackageRoots.add(packageRoot);
+        const manifest = resolveInstalledPackageBindingsManifest(packageRoot);
+        if (!manifest.ok)
+            return manifest;
+        if (manifest.value)
+            out.push(manifest.value);
+        const childDeps = readInstalledPackageDependencyNames(packageRoot);
+        if (!childDeps.ok)
+            return childDeps;
+        for (const childName of childDeps.value) {
+            queue.push({
+                dependencyName: childName,
+                fromDir: packageRoot,
+                rootDependency: false,
+            });
+        }
+    }
+    return {
+        ok: true,
+        value: out.sort((a, b) => normalizeId(a.packageName).localeCompare(normalizeId(b.packageName))),
+    };
+};
+export const mergeManifestIntoWorkspaceConfig = (config, manifest, conflictCode = undefined) => {
+    const dotnet = config.dotnet ?? {};
+    const testDotnet = config.testDotnet ?? {};
+    const mergedFramework = mergeFrameworkReferences((dotnet.frameworkReferences ?? []), (manifest.dotnet?.frameworkReferences ?? []), conflictCode);
+    if (!mergedFramework.ok)
+        return mergedFramework;
+    const mergedPackages = mergePackageReferences((dotnet.packageReferences ?? []), (manifest.dotnet?.packageReferences ?? []), conflictCode);
+    if (!mergedPackages.ok)
+        return mergedPackages;
+    const mergedMsbuild = mergeMsbuildProperties((dotnet.msbuildProperties ?? {}), (manifest.dotnet?.msbuildProperties ?? {}), conflictCode);
+    if (!mergedMsbuild.ok)
+        return mergedMsbuild;
+    const mergedTestFramework = mergeFrameworkReferences((testDotnet.frameworkReferences ?? []), (manifest.testDotnet?.frameworkReferences ??
+        []), conflictCode);
+    if (!mergedTestFramework.ok)
+        return mergedTestFramework;
+    const mergedTestPackages = mergePackageReferences((testDotnet.packageReferences ?? []), (manifest.testDotnet?.packageReferences ?? []), conflictCode);
+    if (!mergedTestPackages.ok)
+        return mergedTestPackages;
+    const mergedTestMsbuild = mergeMsbuildProperties((testDotnet.msbuildProperties ?? {}), (manifest.testDotnet?.msbuildProperties ?? {}), conflictCode);
+    if (!mergedTestMsbuild.ok)
+        return mergedTestMsbuild;
+    return {
+        ok: true,
+        value: {
+            ...config,
+            dotnet: {
+                ...dotnet,
+                frameworkReferences: mergedFramework.value,
+                packageReferences: mergedPackages.value,
+                msbuildProperties: Object.keys(mergedMsbuild.value).length > 0
+                    ? mergedMsbuild.value
+                    : undefined,
+            },
+            testDotnet: manifest.testDotnet
+                ? {
+                    ...testDotnet,
+                    frameworkReferences: mergedTestFramework.value,
+                    packageReferences: mergedTestPackages.value,
+                    msbuildProperties: Object.keys(mergedTestMsbuild.value).length > 0
+                        ? mergedTestMsbuild.value
+                        : undefined,
+                }
+                : config.testDotnet,
+        },
+    };
+};
+export const applyAikyaWorkspaceOverlay = (workspaceRoot, config) => {
+    const manifests = discoverWorkspaceBindingsManifests(workspaceRoot);
+    if (!manifests.ok)
+        return manifests;
+    let current = config;
+    for (const manifest of manifests.value) {
+        const merged = mergeManifestIntoWorkspaceConfig(current, manifest, AIKYA_DIAGNOSTIC.conflictingRuntime);
+        if (!merged.ok)
+            return merged;
+        current = merged.value;
+    }
+    return { ok: true, value: { config: current, manifests: manifests.value } };
+};
+//# sourceMappingURL=bindings.js.map