@multiplatform.one/config 7.20.0 → 7.22.0

package/lib/index.js

@@ -1,5 +1,5 @@
-import { t as createViteConfig } from "./vite-DXXr5In0.js";
-import { t as createStorybookViteConfig } from "./storybook-DFdvDJ_s.js";
+import { t as createViteConfig } from "./vite-CS7fRWSI.js";
+import { t as createStorybookViteConfig } from "./storybook-BqMQy98f.js";
 import { n as tamaguiWorkspacePathsFile, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-ZIcqybtn.js";
 import { createVitestConfig } from "./vitest.js";
 

package/lib/{storybook-DFdvDJ_s.js → storybook-BqMQy98f.js}

@@ -1,4 +1,4 @@
-import { i as withSingletonDepAliases, r as resolvePackageMainSource, t as discoverPublicPackageRoots } from "./workspacePublicPackages-BuYRXxFs.js";
+import { i as withSingletonDepAliases, r as resolvePackageMainSource, t as discoverPublicPackageRoots } from "./workspacePublicPackages-B9ho3BjU.js";
 import { t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-ZIcqybtn.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";

package/lib/storybook.js

@@ -1,3 +1,3 @@
-import { t as createStorybookViteConfig } from "./storybook-DFdvDJ_s.js";
+import { t as createStorybookViteConfig } from "./storybook-BqMQy98f.js";
 
 export { createStorybookViteConfig };

package/lib/{vite-DXXr5In0.js → vite-CS7fRWSI.js}

@@ -1,4 +1,4 @@
-import { i as withSingletonDepAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-BuYRXxFs.js";
+import { i as withSingletonDepAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-B9ho3BjU.js";
 import { t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-ZIcqybtn.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";

package/lib/vite.js

@@ -1,4 +1,4 @@
-import { n as publicConfigPlugin, r as readPublicConfigKeys, t as createViteConfig } from "./vite-DXXr5In0.js";
-import { n as publicPackageViteSourceAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-BuYRXxFs.js";
+import { n as publicConfigPlugin, r as readPublicConfigKeys, t as createViteConfig } from "./vite-CS7fRWSI.js";
+import { n as publicPackageViteSourceAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-B9ho3BjU.js";
 
 export { createViteConfig, discoverPublicPackageRoots, publicConfigPlugin, publicPackageViteSourceAliases, readPublicConfigKeys };

package/lib/{workspacePublicPackages-BuYRXxFs.js → workspacePublicPackages-B9ho3BjU.js}

@@ -208,17 +208,96 @@ function resolvePackageMainSource(pkgDir) {
 		path.join(pkgDir, "index.tsx")
 	].find((c) => fs.existsSync(c));
 }
+const webConditionOrder = [
+	"import",
+	"default",
+	"require"
+];
+const skippedConditions = new Set(["types", "react-native"]);
+const tsSourcePattern = /\.(c|m)?tsx?$/;
+function collectExportTargets(target, out) {
+	if (typeof target === "string") {
+		out.push(target);
+		return;
+	}
+	if (!target) return;
+	if (Array.isArray(target)) {
+		for (const item of target) collectExportTargets(item, out);
+		return;
+	}
+	if (typeof target.source === "string") out.push(target.source);
+	const keys = Object.keys(target).filter((k) => k !== "source" && !skippedConditions.has(k));
+	const ordered = [...webConditionOrder.filter((k) => keys.includes(k)), ...keys.filter((k) => !webConditionOrder.includes(k))];
+	for (const key of ordered) collectExportTargets(target[key], out);
+}
 /**
-* Vite `resolve.alias` entries: each public package name → its TypeScript main.
-* For SPA / ad-hoc Vite configs that should not list packages by hand.
+* The file a web build should compile for one `exports` entry: its `source`
+* condition, else the first TypeScript file among its web conditions, else
+* the first existing file (css, a prebuilt .mjs), so the package-name alias
+* never swallows a subpath it cannot see.
 */
-function publicPackageViteSourceAliases(workspaceRoot) {
+function resolveExportSource(pkgDir, target) {
+	const candidates = [];
+	collectExportTargets(target, candidates);
+	const existing = candidates.map((c) => path.resolve(pkgDir, c)).filter((c) => !c.endsWith(".d.ts") && fs.existsSync(c) && fs.statSync(c).isFile());
+	return existing.find((c) => tsSourcePattern.test(c)) ?? existing[0];
+}
+/**
+* Vite `resolve.alias` entries for one package's `exports` subpaths:
+* `<name>/<subpath>` → its source file, and a `./dir/*` pattern → the directory.
+*/
+function packageSubpathSourceAliases(pkgName, pkgDir, exportsField) {
 	const aliases = {};
+	if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField)) return aliases;
+	for (const [key, target] of Object.entries(exportsField)) {
+		if (key === "." || key === "./package.json" || !key.startsWith("./")) continue;
+		if (key.endsWith("/*")) {
+			const pattern = key.slice(2, -2);
+			if (pattern.includes("*")) continue;
+			const targets = [];
+			collectExportTargets(target, targets);
+			const dirTarget = targets.find((t) => t.endsWith("/*"));
+			if (!dirTarget) continue;
+			const dir = path.resolve(pkgDir, dirTarget.slice(0, -2));
+			if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) aliases[`${pkgName}/${pattern}`] = dir;
+			continue;
+		}
+		if (key.includes("*")) continue;
+		const file = resolveExportSource(pkgDir, target);
+		if (file) aliases[`${pkgName}/${key.slice(2)}`] = file;
+	}
+	return aliases;
+}
+/**
+* Vite `resolve.alias` entries: each public package name → its TypeScript
+* main, plus every `exports` subpath → its own source file. For SPA / ad-hoc
+* Vite configs that should not list packages by hand.
+*
+* Vite matches a string alias as a prefix at a `/` boundary and takes the
+* first match, so a bare `@multiplatform.one/gpg` → `src/index.ts` entry
+* rewrites `@multiplatform.one/gpg/signer` to `src/index.ts/signer` (MPO-391,
+* MPO-323). Subpath entries are therefore emitted before every bare name,
+* longest first.
+*/
+function publicPackageViteSourceAliases(workspaceRoot) {
+	const subpaths = {};
+	const mains = {};
 	for (const [name, dir] of discoverPublicPackageRoots(workspaceRoot)) {
 		const main = resolvePackageMainSource(dir);
-		if (main) aliases[name] = main;
+		if (main) mains[name] = main;
+		let exportsField;
+		try {
+			exportsField = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).exports;
+		} catch {
+			continue;
+		}
+		Object.assign(subpaths, packageSubpathSourceAliases(name, dir, exportsField));
 	}
-	return aliases;
+	const ordered = Object.keys(subpaths).sort((a, b) => b.length - a.length);
+	return {
+		...Object.fromEntries(ordered.map((k) => [k, subpaths[k]])),
+		...mains
+	};
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/config",
-  "version": "7.20.0",
+  "version": "7.22.0",
   "description": "Shared build and test configuration presets for multiplatform.one",
   "keywords": [
     "config",
@@ -99,7 +99,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@multiplatform.one/utils": "7.20.0",
+    "@multiplatform.one/utils": "7.22.0",
     "@tamagui/vite-plugin": "2.7.6",
     "@vitejs/plugin-react": "^6.0.1",
     "dotenv": "^17.4.2",

package/src/workspacePublicPackages.spec.ts

@@ -1,12 +1,17 @@
-import { describe, expect, it } from "vitest";
+import { afterAll, describe, expect, it } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import {
   discoverPublicPackageRoots,
+  packageSubpathSourceAliases,
+  resolveExportSource,
   resolvePackageMainSource,
   publicPackageViteSourceAliases,
 } from "./workspacePublicPackages";
 
 const workspaceRoot = path.resolve(__dirname, "../../..");
+const pub = (p: string) => path.join(workspaceRoot, "public", p);
 
 describe("discoverPublicPackageRoots", () => {
   it("returns a Map of package names to their directories", () => {
@@ -58,10 +63,74 @@ describe("publicPackageViteSourceAliases", () => {
     expect(Object.keys(aliases).length).toBeGreaterThan(0);
   });
 
-  it("each alias value points to a .ts or .tsx file", () => {
+  it("each bare package alias points to a .ts or .tsx file", () => {
     const aliases = publicPackageViteSourceAliases(workspaceRoot);
-    for (const [, filePath] of Object.entries(aliases)) {
-      expect(filePath).toMatch(/\.(ts|tsx)$/);
+    for (const name of discoverPublicPackageRoots(workspaceRoot).keys()) {
+      if (aliases[name]) expect(aliases[name]).toMatch(/\.(ts|tsx)$/);
+    }
+  });
+
+  it("every alias value exists on disk", () => {
+    const aliases = publicPackageViteSourceAliases(workspaceRoot);
+    for (const [, target] of Object.entries(aliases)) {
+      expect(fs.existsSync(target)).toBe(true);
+    }
+  });
+
+  it("resolves the bare gpg package to src/index.ts and its signer subpath to src/signer.ts", () => {
+    const aliases = publicPackageViteSourceAliases(workspaceRoot);
+    expect(aliases["@multiplatform.one/gpg"]).toBe(pub("gpg/src/index.ts"));
+    expect(aliases["@multiplatform.one/gpg/signer"]).toBe(pub("gpg/src/signer.ts"));
+  });
+
+  it("resolves the web3 subpaths to their source files", () => {
+    const aliases = publicPackageViteSourceAliases(workspaceRoot);
+    expect(aliases["@multiplatform.one/web3/connectkit"]).toBe(pub("web3/src/connectkit/index.ts"));
+    expect(aliases["@multiplatform.one/web3/solana"]).toBe(pub("web3/src/solana.ts"));
+  });
+
+  it("derives every subpath apps/one used to alias by hand", () => {
+    const aliases = publicPackageViteSourceAliases(workspaceRoot);
+    expect(aliases).toMatchObject({
+      "@multiplatform.one/frappe/devtools": pub("frappe/src/devtools/index.ts"),
+      "@multiplatform.one/markdown/mermaid": pub("markdown/src/mermaid/index.ts"),
+      "@multiplatform.one/core/healthz": pub("core/src/healthz.ts"),
+      "@multiplatform.one/backoffice/one-adapter": pub("backoffice/src/oneAdapter/index.tsx"),
+      "@multiplatform.one/frappe-ui/dependsOn": pub("frappe-ui/src/dependsOn.ts"),
+      "@multiplatform.one/frappe-ui/formActions": pub("frappe-ui/src/formEngine/formActions.ts"),
+      "@multiplatform.one/platform/file": pub("platform/src/file/index.ts"),
+      "@multiplatform.one/frappe-ui/src": pub("frappe-ui/src"),
+    });
+  });
+
+  it("orders every subpath alias before every bare package alias", () => {
+    const keys = Object.keys(publicPackageViteSourceAliases(workspaceRoot));
+    const roots = discoverPublicPackageRoots(workspaceRoot);
+    const firstBare = keys.findIndex((k) => roots.has(k));
+    const lastSubpath = keys.reduce((last, k, i) => (roots.has(k) ? last : i), -1);
+    expect(firstBare).toBeGreaterThan(lastSubpath);
+  });
+
+  it("resolves every exported subpath specifier to a real file under Vite's first-match prefix rule", () => {
+    const aliases = Object.entries(publicPackageViteSourceAliases(workspaceRoot));
+    const viteResolve = (spec: string) => {
+      const hit = aliases.find(([find]) => spec === find || spec.startsWith(`${find}/`));
+      return hit ? spec.replace(hit[0], hit[1]) : undefined;
+    };
+    for (const [name, dir] of discoverPublicPackageRoots(workspaceRoot)) {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+      if (!pkg.exports || typeof pkg.exports !== "object") continue;
+      for (const [key, target] of Object.entries(pkg.exports)) {
+        if (key === "." || key === "./package.json" || key.includes("*")) continue;
+        const typesOnly =
+          typeof target === "object" && target !== null && Object.keys(target).join() === "types";
+        if (typesOnly) continue;
+        const spec = `${name}/${key.slice(2)}`;
+        const resolved = viteResolve(spec);
+        if (resolved === undefined) continue;
+        const isFile = fs.existsSync(resolved) && fs.statSync(resolved).isFile();
+        expect({ spec, isFile }).toEqual({ spec, isFile: true });
+      }
     }
   });
 
@@ -70,3 +139,78 @@ describe("publicPackageViteSourceAliases", () => {
     expect(aliases["@multiplatform.one/platform"]).toBeDefined();
   });
 });
+
+describe("packageSubpathSourceAliases", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mpo-subpath-"));
+  const touch = (p: string) => {
+    fs.mkdirSync(path.dirname(path.join(dir, p)), { recursive: true });
+    fs.writeFileSync(path.join(dir, p), "");
+  };
+  touch("src/index.ts");
+  touch("src/signer.ts");
+  touch("src/one.ts");
+  touch("src/deep/entry.tsx");
+  touch("css/theme.css");
+  touch("dist/esm/signer.mjs");
+  afterAll(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+  it("maps a subpath to its source condition, not its dist import", () => {
+    const aliases = packageSubpathSourceAliases("@x/pkg", dir, {
+      ".": { source: "./src/index.ts", import: "./dist/esm/index.mjs" },
+      "./signer": {
+        source: "./src/signer.ts",
+        types: "./types/signer.d.ts",
+        import: "./dist/esm/signer.mjs",
+      },
+    });
+    expect(aliases).toEqual({ "@x/pkg/signer": path.join(dir, "src/signer.ts") });
+  });
+
+  it("falls back to a TypeScript file among the web conditions when there is no source", () => {
+    const aliases = packageSubpathSourceAliases("@x/pkg", dir, {
+      "./one": { types: "./types/one.d.ts", import: "./src/one.ts", require: "./src/one.ts" },
+    });
+    expect(aliases["@x/pkg/one"]).toBe(path.join(dir, "src/one.ts"));
+  });
+
+  it("ignores the react-native branch on the web", () => {
+    const aliases = packageSubpathSourceAliases("@x/pkg", dir, {
+      "./deep": {
+        "react-native": { import: "./src/one.ts" },
+        default: "./src/deep/entry.tsx",
+      },
+    });
+    expect(aliases["@x/pkg/deep"]).toBe(path.join(dir, "src/deep/entry.tsx"));
+  });
+
+  it("keeps a non-source subpath on its real file so the bare alias cannot swallow it", () => {
+    const aliases = packageSubpathSourceAliases("@x/pkg", dir, {
+      "./css/theme.css": { import: "./css/theme.css" },
+    });
+    expect(aliases["@x/pkg/css/theme.css"]).toBe(path.join(dir, "css/theme.css"));
+  });
+
+  it("maps a directory wildcard to the directory", () => {
+    const aliases = packageSubpathSourceAliases("@x/pkg", dir, { "./src/*": "./src/*" });
+    expect(aliases["@x/pkg/src"]).toBe(path.join(dir, "src"));
+  });
+
+  it("skips types-only and missing targets", () => {
+    const aliases = packageSubpathSourceAliases("@x/pkg", dir, {
+      "./types-only": { types: "./src/overrides.d.ts" },
+      "./missing": { source: "./src/nope.ts", import: "./dist/esm/nope.mjs" },
+    });
+    expect(aliases).toEqual({});
+  });
+
+  it("returns nothing for a string or absent exports field", () => {
+    expect(packageSubpathSourceAliases("@x/pkg", dir, "./src/index.ts")).toEqual({});
+    expect(packageSubpathSourceAliases("@x/pkg", dir, undefined)).toEqual({});
+  });
+
+  it("resolveExportSource prefers TypeScript over an existing dist file", () => {
+    expect(
+      resolveExportSource(dir, { import: "./dist/esm/signer.mjs", default: "./src/signer.ts" }),
+    ).toBe(path.join(dir, "src/signer.ts"));
+  });
+});

package/src/workspacePublicPackages.ts

@@ -56,15 +56,113 @@ export function resolvePackageMainSource(pkgDir: string): string | undefined {
   return candidates.find((c) => fs.existsSync(c));
 }
 
+type ExportTarget = string | null | ExportTarget[] | { [condition: string]: ExportTarget };
+
+const webConditionOrder = ["import", "default", "require"];
+const skippedConditions = new Set(["types", "react-native"]);
+const tsSourcePattern = /\.(c|m)?tsx?$/;
+
+function collectExportTargets(target: ExportTarget, out: string[]): void {
+  if (typeof target === "string") {
+    out.push(target);
+    return;
+  }
+  if (!target) return;
+  if (Array.isArray(target)) {
+    for (const item of target) collectExportTargets(item, out);
+    return;
+  }
+  if (typeof target.source === "string") out.push(target.source);
+  const keys = Object.keys(target).filter((k) => k !== "source" && !skippedConditions.has(k));
+  const ordered = [
+    ...webConditionOrder.filter((k) => keys.includes(k)),
+    ...keys.filter((k) => !webConditionOrder.includes(k)),
+  ];
+  for (const key of ordered) collectExportTargets(target[key], out);
+}
+
 /**
- * Vite `resolve.alias` entries: each public package name → its TypeScript main.
- * For SPA / ad-hoc Vite configs that should not list packages by hand.
+ * The file a web build should compile for one `exports` entry: its `source`
+ * condition, else the first TypeScript file among its web conditions, else
+ * the first existing file (css, a prebuilt .mjs), so the package-name alias
+ * never swallows a subpath it cannot see.
  */
-export function publicPackageViteSourceAliases(workspaceRoot: string): Record<string, string> {
+export function resolveExportSource(pkgDir: string, target: ExportTarget): string | undefined {
+  const candidates: string[] = [];
+  collectExportTargets(target, candidates);
+  const existing = candidates
+    .map((c) => path.resolve(pkgDir, c))
+    .filter((c) => !c.endsWith(".d.ts") && fs.existsSync(c) && fs.statSync(c).isFile());
+  return existing.find((c) => tsSourcePattern.test(c)) ?? existing[0];
+}
+
+/**
+ * Vite `resolve.alias` entries for one package's `exports` subpaths:
+ * `<name>/<subpath>` → its source file, and a `./dir/*` pattern → the directory.
+ */
+export function packageSubpathSourceAliases(
+  pkgName: string,
+  pkgDir: string,
+  exportsField: unknown,
+): Record<string, string> {
   const aliases: Record<string, string> = {};
+  if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField)) {
+    return aliases;
+  }
+  for (const [key, target] of Object.entries(exportsField as Record<string, ExportTarget>)) {
+    if (key === "." || key === "./package.json" || !key.startsWith("./")) continue;
+    if (key.endsWith("/*")) {
+      const pattern = key.slice(2, -2);
+      if (pattern.includes("*")) continue;
+      const targets: string[] = [];
+      collectExportTargets(target, targets);
+      const dirTarget = targets.find((t) => t.endsWith("/*"));
+      if (!dirTarget) continue;
+      const dir = path.resolve(pkgDir, dirTarget.slice(0, -2));
+      if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+        aliases[`${pkgName}/${pattern}`] = dir;
+      }
+      continue;
+    }
+    if (key.includes("*")) continue;
+    const file = resolveExportSource(pkgDir, target);
+    if (file) aliases[`${pkgName}/${key.slice(2)}`] = file;
+  }
+  return aliases;
+}
+
+/**
+ * Vite `resolve.alias` entries: each public package name → its TypeScript
+ * main, plus every `exports` subpath → its own source file. For SPA / ad-hoc
+ * Vite configs that should not list packages by hand.
+ *
+ * Vite matches a string alias as a prefix at a `/` boundary and takes the
+ * first match, so a bare `@multiplatform.one/gpg` → `src/index.ts` entry
+ * rewrites `@multiplatform.one/gpg/signer` to `src/index.ts/signer` (MPO-391,
+ * MPO-323). Subpath entries are therefore emitted before every bare name,
+ * longest first.
+ */
+export function publicPackageViteSourceAliases(workspaceRoot: string): Record<string, string> {
+  const subpaths: Record<string, string> = {};
+  const mains: Record<string, string> = {};
   for (const [name, dir] of discoverPublicPackageRoots(workspaceRoot)) {
     const main = resolvePackageMainSource(dir);
-    if (main) aliases[name] = main;
+    if (main) mains[name] = main;
+    let exportsField: unknown;
+    try {
+      exportsField = (
+        JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")) as {
+          exports?: unknown;
+        }
+      ).exports;
+    } catch {
+      continue;
+    }
+    Object.assign(subpaths, packageSubpathSourceAliases(name, dir, exportsField));
   }
-  return aliases;
+  const ordered = Object.keys(subpaths).sort((a, b) => b.length - a.length);
+  return {
+    ...Object.fromEntries(ordered.map((k) => [k, subpaths[k] as string])),
+    ...mains,
+  };
 }

package/types/workspacePublicPackages.d.ts

@@ -16,9 +16,32 @@ export declare function discoverPublicPackageRoots(workspaceRoot: string): Map<s
  * web-only side effects (fontsource @font-face CSS imports) never load.
  */
 export declare function resolvePackageMainSource(pkgDir: string): string | undefined;
+type ExportTarget = string | null | ExportTarget[] | {
+    [condition: string]: ExportTarget;
+};
 /**
- * Vite `resolve.alias` entries: each public package name → its TypeScript main.
- * For SPA / ad-hoc Vite configs that should not list packages by hand.
+ * The file a web build should compile for one `exports` entry: its `source`
+ * condition, else the first TypeScript file among its web conditions, else
+ * the first existing file (css, a prebuilt .mjs), so the package-name alias
+ * never swallows a subpath it cannot see.
+ */
+export declare function resolveExportSource(pkgDir: string, target: ExportTarget): string | undefined;
+/**
+ * Vite `resolve.alias` entries for one package's `exports` subpaths:
+ * `<name>/<subpath>` → its source file, and a `./dir/*` pattern → the directory.
+ */
+export declare function packageSubpathSourceAliases(pkgName: string, pkgDir: string, exportsField: unknown): Record<string, string>;
+/**
+ * Vite `resolve.alias` entries: each public package name → its TypeScript
+ * main, plus every `exports` subpath → its own source file. For SPA / ad-hoc
+ * Vite configs that should not list packages by hand.
+ *
+ * Vite matches a string alias as a prefix at a `/` boundary and takes the
+ * first match, so a bare `@multiplatform.one/gpg` → `src/index.ts` entry
+ * rewrites `@multiplatform.one/gpg/signer` to `src/index.ts/signer` (MPO-391,
+ * MPO-323). Subpath entries are therefore emitted before every bare name,
+ * longest first.
  */
 export declare function publicPackageViteSourceAliases(workspaceRoot: string): Record<string, string>;
+export {};
 //# sourceMappingURL=workspacePublicPackages.d.ts.map

package/types/workspacePublicPackages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspacePublicPackages.d.ts","sourceRoot":"","sources":["../src/workspacePublicPackages.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAmBrF;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAgB3E;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAO5F"}
+{"version":3,"file":"workspacePublicPackages.d.ts","sourceRoot":"","sources":["../src/workspacePublicPackages.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAmBrF;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAgB3E;AAED,KAAK,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,YAAY,EAAE,GAAG;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAC;AAyB3F;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAO5F;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,OAAO,GACpB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAyBxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAuB5F"}