@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/esm/ultramodern-workspace/descriptors.js

@@ -1,5 +1,16 @@
 import { packageName, toCamelCase, toEnvSegment, toKebabCase, toPascalCase } from "./naming.js";
 const ULTRAMODERN_CONFIG_PATH = '.modernjs/ultramodern.json';
+function distributedSsrExposes(app) {
+    return Object.keys(app.exposes ?? {}).filter((expose)=>'./Route' !== expose).toSorted();
+}
+function distributedSsrFragmentSlug(expose) {
+    const slug = toKebabCase(expose.replace(/^\.\//u, ''));
+    if (!slug) throw new Error(`Invalid distributed SSR expose ${expose}.`);
+    return slug;
+}
+function distributedSsrFragmentRoute(expose) {
+    return `/{locale}/_mf/fragment/${distributedSsrFragmentSlug(expose)}`;
+}
 const shellApp = {
     id: 'shell-super-app',
     directory: 'apps/shell-super-app',
@@ -25,10 +36,10 @@ const shellApp = {
         }
     }
 };
-function createShellHost(remotes = []) {
+function createShellHost(remotes = [], verticalRefs = remotes.filter(appEmitsBrowserUi).map((remote)=>remote.id)) {
     return {
         ...shellApp,
-        verticalRefs: remotes.map((remote)=>remote.id)
+        verticalRefs
     };
 }
 const sharedPackages = [
@@ -58,7 +69,12 @@ function createNeutralOwnership(id, tier = 'tier-2-vertical') {
         }
     };
 }
-function createVerticalDescriptor(name, port) {
+function createVerticalDescriptor(name, port, options = {}) {
+    const horizontalRemote = options.horizontalRemote ?? false;
+    const preset = horizontalRemote ? 'ui-only' : options.preset ?? 'full-stack';
+    const apiProtocol = options.apiProtocol ?? 'rest';
+    const emitsUi = 'api-only' !== preset;
+    const emitsApi = 'ui-only' !== preset;
     const domain = toKebabCase(name);
     const id = domain;
     const displayPrefix = toPascalCase(domain).replace(/([a-z])([A-Z])/g, '$1 $2');
@@ -72,24 +88,43 @@ function createVerticalDescriptor(name, port) {
         portEnv: `VERTICAL_${toEnvSegment(domain)}_PORT`,
         port,
         mfName: `vertical${toPascalCase(domain)}`,
-        exposes: {
-            './Route': './src/federation-entry.tsx',
-            './Widget': `./src/components/${domain}-widget.tsx`
-        },
-        api: {
-            stem: domain,
-            prefix: `/${domain}-api`,
-            consumedBy: [
-                shellApp.id,
-                id
-            ]
-        },
+        ...emitsUi ? {
+            exposes: {
+                './Route': './src/federation-entry.tsx',
+                './Widget': `./src/components/${domain}-widget.tsx`
+            }
+        } : {},
+        ...emitsApi ? {
+            api: {
+                stem: domain,
+                prefix: `/${domain}-api`,
+                consumedBy: [
+                    shellApp.id,
+                    id
+                ],
+                ...'rest' !== apiProtocol ? {
+                    protocol: apiProtocol
+                } : {}
+            }
+        } : {},
+        ...'full-stack' !== preset ? {
+            surfaceProfile: preset
+        } : {},
+        ...horizontalRemote ? {
+            deliveryUnitKind: 'horizontal-remote'
+        } : {},
         ownership: createNeutralOwnership(id)
     };
 }
 function appHasApi(app) {
     return void 0 !== app.api;
 }
+function appEmitsBrowserUi(app) {
+    return 'api-only' !== app.surfaceProfile;
+}
+function resolveApiProtocol(app) {
+    return app.api?.protocol ?? 'rest';
+}
 function resolveApiPrefix(target) {
     return target.api?.prefix ?? `/${toKebabCase(target.id)}-api`;
 }
@@ -107,11 +142,34 @@ function zephyrRemoteDependency(scope, remote) {
 }
 function resolveRemoteRefs(app, remotes = []) {
     const verticalRefs = app.verticalRefs ?? [];
-    return verticalRefs.map((remoteRef)=>remotes.find((remote)=>remote.id === remoteRef)).filter((remote)=>void 0 !== remote);
+    const remotesById = new Map(remotes.map((remote)=>[
+            remote.id,
+            remote
+        ]));
+    return verticalRefs.map((remoteRef)=>{
+        const remote = remotesById.get(remoteRef);
+        if (void 0 === remote) {
+            const availableRemotes = remotes.map((remote)=>remote.id).join(', ');
+            throw new Error(`Unknown remote vertical reference ${remoteRef} for ${app.id}. Available remotes: ${availableRemotes || 'none'}.`);
+        }
+        return remote;
+    });
 }
 function createRemoteManifestEnv(remote) {
     return `VERTICAL_${toEnvSegment(remote.domain ?? remote.id)}_MF_MANIFEST`;
 }
+function createBackendFederationManifestEnv(remote) {
+    return `VERTICAL_${toEnvSegment(remote.domain ?? remote.id)}_BACKEND_MF_MANIFEST`;
+}
+function createBackendFederationName(app) {
+    return `${app.mfName}Backend`;
+}
+function createBackendFederationManifestUrl(app) {
+    return `http://localhost:${app.port}/backend-mf-manifest.json`;
+}
+function createBackendFederationContainerEntry(app) {
+    return `http://localhost:${app.port}/backendRemoteEntry.cjs`;
+}
 function createModuleFederationRemoteContracts(app, remotes = []) {
     return resolveRemoteRefs(app, remotes).map((remote)=>({
             id: remote.id,
@@ -130,4 +188,4 @@ function createCloudflarePublicUrlEnv(app) {
 function appI18nNamespace(app) {
     return 'shell' === app.kind ? 'shell' : app.domain ?? app.id;
 }
-export { ULTRAMODERN_CONFIG_PATH, appHasApi, appI18nNamespace, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, remoteDependencyAlias, resolveApiPrefix, resolveApiStem, resolveRemoteRefs, sharedPackages, shellApp, verticalApiApps, zephyrRemoteDependency };
+export { ULTRAMODERN_CONFIG_PATH, appEmitsBrowserUi, appHasApi, appI18nNamespace, createBackendFederationContainerEntry, createBackendFederationManifestEnv, createBackendFederationManifestUrl, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, distributedSsrExposes, distributedSsrFragmentRoute, distributedSsrFragmentSlug, remoteDependencyAlias, resolveApiPrefix, resolveApiProtocol, resolveApiStem, resolveRemoteRefs, sharedPackages, shellApp, verticalApiApps, zephyrRemoteDependency };

package/dist/esm/ultramodern-workspace/effect-diagnostics.js

@@ -0,0 +1,76 @@
+const effectDiagnostics = [
+    'anyUnknownInErrorContext',
+    'classSelfMismatch',
+    'duplicatePackage',
+    'effectFnImplicitAny',
+    'floatingEffect',
+    'genericEffectServices',
+    'missingEffectContext',
+    'missingEffectError',
+    'missingLayerContext',
+    'missingReturnYieldStar',
+    'missingStarInYieldEffectGen',
+    'nonObjectEffectServiceType',
+    'outdatedApi',
+    'overriddenSchemaConstructor',
+    'catchUnfailableEffect',
+    'effectFnIife',
+    'effectGenUsesAdapter',
+    'effectInFailure',
+    'effectInVoidSuccess',
+    'globalErrorInEffectCatch',
+    'globalErrorInEffectFailure',
+    'layerMergeAllWithDependencies',
+    'lazyPromiseInEffectSync',
+    'leakingRequirements',
+    'multipleEffectProvide',
+    'returnEffectInGen',
+    'runEffectInsideEffect',
+    'schemaSyncInEffect',
+    'scopeInLayerEffect',
+    'strictEffectProvide',
+    'tryCatchInEffectGen',
+    'unknownInEffectCatch',
+    'asyncFunction',
+    'cryptoRandomUUID',
+    'cryptoRandomUUIDInEffect',
+    'extendsNativeError',
+    'globalConsole',
+    'globalConsoleInEffect',
+    'globalDate',
+    'globalDateInEffect',
+    'globalFetch',
+    'globalFetchInEffect',
+    'globalRandom',
+    'globalRandomInEffect',
+    'globalTimers',
+    'globalTimersInEffect',
+    'instanceOfSchema',
+    'newPromise',
+    'nodeBuiltinImport',
+    'preferSchemaOverJson',
+    'processEnv',
+    'processEnvInEffect',
+    'unsafeEffectTypeAssertion',
+    'catchAllToMapError',
+    'deterministicKeys',
+    'effectDoNotation',
+    'effectFnOpportunity',
+    'effectMapFlatten',
+    'effectMapVoid',
+    'effectSucceedWithVoid',
+    'missedPipeableOpportunity',
+    'missingEffectServiceDependency',
+    'nestedEffectGenYield',
+    'redundantSchemaTagIdentifier',
+    'schemaStructWithTag',
+    'schemaUnionOfLiterals',
+    'serviceNotAsClass',
+    'strictBooleanExpressions',
+    'unnecessaryArrowBlock',
+    'unnecessaryEffectGen',
+    'unnecessaryFailYieldableError',
+    'unnecessaryPipe',
+    'unnecessaryPipeChain'
+];
+export { effectDiagnostics };

package/dist/esm/ultramodern-workspace/fs-io.js

@@ -1,5 +1,4 @@
 import { spawnSync } from "node:child_process";
-import node_crypto from "node:crypto";
 import node_fs from "node:fs";
 import { createRequire } from "node:module";
 import node_path from "node:path";
@@ -51,9 +50,31 @@ function renderFileTemplate(relativePath, data) {
 function assertSafeRelativePath(relativePath) {
     if (0 === relativePath.length || node_path.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes('..')) throw new Error(`Unsafe workspace template path: ${relativePath}`);
 }
-function ensureInsideRoot(root, targetPath) {
+function isPathInsideRoot(root, targetPath) {
     const relativePath = node_path.relative(root, targetPath);
-    if (relativePath.startsWith('..') || node_path.isAbsolute(relativePath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+    return '' === relativePath || !relativePath.startsWith('..') && !node_path.isAbsolute(relativePath);
+}
+function findExistingAncestor(targetPath) {
+    let currentPath = targetPath;
+    while(!node_fs.existsSync(currentPath)){
+        const parentPath = node_path.dirname(currentPath);
+        if (parentPath === currentPath) return;
+        currentPath = parentPath;
+    }
+    return currentPath;
+}
+function ensureInsideRoot(root, targetPath) {
+    const absoluteRoot = node_path.resolve(root);
+    const absoluteTargetPath = node_path.resolve(targetPath);
+    if (!isPathInsideRoot(absoluteRoot, absoluteTargetPath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+    if (!node_fs.existsSync(absoluteRoot)) return;
+    const existingAncestor = findExistingAncestor(absoluteTargetPath);
+    if (!existingAncestor) return;
+    const rootRealPath = node_fs.realpathSync.native(absoluteRoot);
+    const ancestorRealPath = node_fs.realpathSync.native(existingAncestor);
+    const unresolvedRelativePath = node_path.relative(existingAncestor, absoluteTargetPath);
+    const resolvedTargetPath = node_path.resolve(ancestorRealPath, unresolvedRelativePath);
+    if (!isPathInsideRoot(rootRealPath, resolvedTargetPath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
 }
 function writeFile(targetDir, relativePath, content) {
     assertSafeRelativePath(relativePath);
@@ -174,21 +195,9 @@ function collectTemplateFiles(dir) {
     collect(dir);
     return files;
 }
-function hashFile(filePath) {
-    return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
-}
-function hashTemplateTree(dir) {
-    const hash = node_crypto.createHash('sha256');
-    for (const relativePath of collectTemplateFiles(dir)){
-        hash.update(relativePath);
-        hash.update('\0');
-        hash.update(hashFile(node_path.join(dir, relativePath)));
-        hash.update('\0');
-    }
-    return hash.digest('hex');
-}
-function copyRootTemplate(targetDir, data) {
+function copyRootTemplate(targetDir, data, excludedRelativePaths = new Set()) {
     for (const relativePath of collectTemplateFiles(workspaceTemplateDir)){
+        if (excludedRelativePaths.has(relativePath)) continue;
         const sourcePath = node_path.join(workspaceTemplateDir, relativePath);
         const outputPath = relativePath.replace(/\.handlebars$/, '');
         const content = relativePath.endsWith('.handlebars') ? renderTemplate(node_fs.readFileSync(sourcePath, 'utf-8'), data) : node_fs.readFileSync(sourcePath, 'utf-8');
@@ -201,4 +210,4 @@ function readJsonFile(filePath) {
 function writeJsonFile(filePath, value) {
     node_fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
 }
-export { assertSafeRelativePath, collectTemplateFiles, copyRootTemplate, createPackageRoot, ensureInsideRoot, fileTemplatesDir, formatGeneratedWorkspaceFiles, hashFile, hashTemplateTree, readFileTemplate, readJsonFile, renderFileTemplate, renderTemplate, workspaceTemplateDir, writeFile, writeFileReplacing, writeJson, writeJsonFile };
+export { copyRootTemplate, createPackageRoot, formatGeneratedWorkspaceFiles, readFileTemplate, readJsonFile, renderFileTemplate, renderTemplate, workspaceTemplateDir, writeFile, writeFileReplacing, writeJson, writeJsonFile };

package/dist/esm/ultramodern-workspace/generation-result.js

@@ -1,8 +1,14 @@
 import node_crypto from "node:crypto";
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { ULTRAMODERN_CONFIG_PATH, appHasApi } from "./descriptors.js";
+import { rpcPath } from "./api/rpc.js";
+import { createDeliveryUnitRecord } from "./delivery-unit.js";
+import { apiSurface, exposeSurface } from "./delivery-unit-schema/up-projection.js";
+import { ULTRAMODERN_CONFIG_PATH, appHasApi, resolveApiProtocol } from "./descriptors.js";
 import { normalizePath, packageName } from "./naming.js";
+import { resolveOwnerAttribution } from "./types.js";
+import { EFFECT_VERSION, REACT_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_VERSION } from "./versions.js";
+const BASELINE_COHORT_ID = 'ultramodern-platform-baseline-v1';
 const ignoredSnapshotDirectories = new Set([
     '.git',
     '.nx',
@@ -72,7 +78,31 @@ function createGenerationResult(options) {
                 app.apiPrefix
             ])),
         generatedContractPath: ULTRAMODERN_CONFIG_PATH,
-        warnings: options.warnings ?? []
+        warnings: options.warnings ?? [],
+        deliveryUnits: options.createdApps.map((app)=>createGeneratedDeliveryUnitDescriptor(options.packageScope, app))
+    };
+}
+function createGeneratedDeliveryUnitDescriptor(scope, app) {
+    const record = createDeliveryUnitRecord(scope, app);
+    const surfaces = Object.entries(app.exposes ?? {}).map(([key, value])=>exposeSurface(app, key, value));
+    if (appHasApi(app)) surfaces.push(apiSurface(app.api, resolveApiProtocol(app), 'rpc' === resolveApiProtocol(app) ? rpcPath(app) : app.api.prefix));
+    const canonicalKind = 'shell' === app.kind ? 'shell' : app.deliveryUnitKind ?? 'microvertical';
+    return {
+        unitId: record.unitId,
+        kind: canonicalKind,
+        owner: resolveOwnerAttribution(app.ownership),
+        sourceRevision: record.sourceRevision,
+        buildMarker: record.buildMarker,
+        baselineCohort: {
+            cohortId: BASELINE_COHORT_ID,
+            resolved: {
+                react: REACT_VERSION,
+                tanstackRouter: TANSTACK_ROUTER_VERSION,
+                effect: EFFECT_VERSION,
+                tailwind: TAILWIND_VERSION
+            }
+        },
+        surfaces
     };
 }
 function createGeneratedAppDescriptor(scope, app) {
@@ -99,4 +129,4 @@ function createGeneratedAppDescriptor(scope, app) {
 function hashFile(filePath) {
     return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
 }
-export { createFileSnapshot, createGenerationResult, diffFileSnapshots };
+export { createFileSnapshot, createGenerationResult, diffFileSnapshots, ignoredSnapshotDirectories };

package/dist/esm/ultramodern-workspace/index.js

@@ -1,4 +1,8 @@
+export { addUltramodernShell, planUltramodernShell } from "./add-shell.js";
 export { addUltramodernVertical, planUltramodernVertical } from "./add-vertical.js";
 export { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
+export { BASELINE_DEPENDENCY_PINS, OverlayBaselineRelaxationError } from "./overlay-baseline-guard.js";
+export { SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES } from "./shared-patches.js";
+export { PRIMARY_SHELL_ID, createShellDescriptor, resolveConfiguredAdditionalShells } from "./shells.js";
 export { ultramodernWorkspaceVersions } from "./versions.js";
 export { generateUltramodernWorkspace } from "./write-workspace.js";

package/dist/esm/ultramodern-workspace/locales.js

@@ -115,8 +115,7 @@ function createAppLocaleMessages(app, language) {
         [messageKey]: messages
     };
 }
-function createAppPublicLocaleMessages(app, language, remotes = []) {
-    if ('shell' !== app.kind) return createAppLocaleMessages(app, language);
-    return Object.assign({}, createAppLocaleMessages(app, language), ...remotes.map((remote)=>createAppLocaleMessages(remote, language)));
+function createAppPublicLocaleMessages(app, language, _remotes = []) {
+    return createAppLocaleMessages(app, language);
 }
-export { commonLocaleMessages, createAppLocaleMessages, createAppPublicLocaleMessages, createFallbackLocaleMessages, generatedLocaleResources };
+export { createAppPublicLocaleMessages };

package/dist/esm/ultramodern-workspace/mf-validation/constants.js

@@ -0,0 +1,19 @@
+const moduleFederationConfigFile = 'module-federation.config.ts';
+const mfTypesArchive = 'dist/@mf-types.zip';
+const generatedMetadataPaths = [
+    '.modernjs/ultramodern.json'
+];
+const defaultAppRootDirs = [
+    'apps',
+    'verticals'
+];
+const skippedScanDirs = new Set([
+    '.git',
+    '.modernjs',
+    '.nx',
+    '.turbo',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+export { defaultAppRootDirs, generatedMetadataPaths, mfTypesArchive, moduleFederationConfigFile, skippedScanDirs };

package/dist/esm/ultramodern-workspace/mf-validation/discovery.js

@@ -0,0 +1,28 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { defaultAppRootDirs, moduleFederationConfigFile } from "./constants.js";
+import { collectBridgeScanRoots, collectMetadataAppDirs, firstSegment, normalizeRelativePath, readGeneratedMetadata, scanForModuleFederationConfigs } from "./path-utils.js";
+function discoverModuleFederationConfigs(options) {
+    const workspaceRoot = node_path.resolve(options.workspaceRoot);
+    const appDirs = new Set();
+    if (options.appDirs && options.appDirs.length > 0) for (const appDir of options.appDirs)appDirs.add(normalizeRelativePath(appDir));
+    else {
+        const metadata = readGeneratedMetadata(workspaceRoot);
+        const scanRoots = new Set(defaultAppRootDirs);
+        for (const metadataEntry of metadata){
+            collectMetadataAppDirs(metadataEntry, appDirs);
+            collectBridgeScanRoots(metadataEntry, scanRoots);
+        }
+        for (const appDir of appDirs){
+            const segment = firstSegment(appDir);
+            if (segment) scanRoots.add(segment);
+        }
+        if (node_fs.existsSync(node_path.join(workspaceRoot, moduleFederationConfigFile))) appDirs.add('.');
+        for (const scanRoot of scanRoots)scanForModuleFederationConfigs(workspaceRoot, scanRoot, appDirs);
+    }
+    return Array.from(appDirs).sort().map((appDir)=>({
+            appDir,
+            configPath: node_path.join(workspaceRoot, appDir, moduleFederationConfigFile)
+        }));
+}
+export { discoverModuleFederationConfigs };

package/dist/esm/ultramodern-workspace/mf-validation/inspect.js

@@ -0,0 +1,46 @@
+import { parseArrayLiteral, parseLiteralString, parseObjectLiteral } from "./object-literal.js";
+import { findCreateModuleFederationConfigObject, findExportDefaultObject } from "./syntax.js";
+function extractExposes(configPath, value) {
+    if (void 0 === value) return [];
+    const object = parseObjectLiteral(value);
+    if (object) {
+        if (object.hasSpread) throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object without spreads.`);
+        return Array.from(object.properties.keys()).sort();
+    }
+    const array = parseArrayLiteral(value);
+    if (array) return array.sort();
+    throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object or string array.`);
+}
+function extractDtsSettings(configPath, value) {
+    if (void 0 === value) return {};
+    const dts = parseObjectLiteral(value);
+    if (!dts || dts.hasSpread) throw new Error(`Cannot statically extract Module Federation DTS settings from ${configPath}; use a literal dts object.`);
+    const generateTypes = parseObjectLiteral(dts.properties.get('generateTypes'));
+    if (generateTypes?.hasSpread) throw new Error(`Cannot statically extract Module Federation generateTypes settings from ${configPath}; use a literal generateTypes object.`);
+    const compilerInstanceSource = generateTypes?.properties.get('compilerInstance');
+    return {
+        compilerInstance: parseLiteralString(compilerInstanceSource) ?? ('tsgoCompilerInstance' === compilerInstanceSource ? 'effect-tsgo' : void 0),
+        tsConfigPath: parseLiteralString(dts.properties.get('tsConfigPath'))
+    };
+}
+function hasHostOnlyNoExposesDeclaration(source) {
+    return /@?ultramodern-mf\s*:?\s*(?:host-only|no-exposes)\b/iu.test(source);
+}
+function inspectModuleFederationConfigSource(source, appDir, configPath) {
+    const configObject = findCreateModuleFederationConfigObject(source) ?? findExportDefaultObject(source);
+    if (!configObject) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; export or pass a literal config object.`);
+    const properties = parseObjectLiteral(configObject);
+    if (!properties) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; expected a literal config object.`);
+    if (properties.hasSpread) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; top-level config spreads are not supported.`);
+    const exposes = extractExposes(configPath, properties.properties.get('exposes'));
+    const hostOnlyNoExposes = hasHostOnlyNoExposesDeclaration(source);
+    if (hostOnlyNoExposes && exposes.length > 0) throw new Error(`Module Federation host-only/no-exposes declaration conflicts with actual exposes in ${configPath}.`);
+    return {
+        appDir,
+        configPath,
+        dts: extractDtsSettings(configPath, properties.properties.get('dts')),
+        exposes,
+        hostOnlyNoExposes
+    };
+}
+export { inspectModuleFederationConfigSource };

package/dist/esm/ultramodern-workspace/mf-validation/object-literal.js

@@ -0,0 +1,144 @@
+import { getOuterBlock, skipSyntax } from "./syntax.js";
+function splitTopLevelEntries(source) {
+    const entries = [];
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    for(let index = 0; index < source.length; index += 1){
+        const skipped = skipSyntax(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        const char = source[index];
+        if ('{' === char) braceDepth += 1;
+        else if ('}' === char) braceDepth -= 1;
+        else if ('[' === char) bracketDepth += 1;
+        else if (']' === char) bracketDepth -= 1;
+        else if ('(' === char) parenDepth += 1;
+        else if (')' === char) parenDepth -= 1;
+        else if (',' === char && 0 === braceDepth && 0 === bracketDepth && 0 === parenDepth) {
+            const entry = source.slice(start, index).trim();
+            if (entry) entries.push(entry);
+            start = index + 1;
+        }
+    }
+    const finalEntry = source.slice(start).trim();
+    if (finalEntry) entries.push(finalEntry);
+    return entries;
+}
+function findTopLevelColon(source) {
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    for(let index = 0; index < source.length; index += 1){
+        const skipped = skipSyntax(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        const char = source[index];
+        if ('{' === char) braceDepth += 1;
+        else if ('}' === char) braceDepth -= 1;
+        else if ('[' === char) bracketDepth += 1;
+        else if (']' === char) bracketDepth -= 1;
+        else if ('(' === char) parenDepth += 1;
+        else if (')' === char) parenDepth -= 1;
+        else if (':' === char && 0 === braceDepth && 0 === bracketDepth && 0 === parenDepth) return index;
+    }
+    return -1;
+}
+function stripConstAssertion(source) {
+    return source.trim().replace(/\s+as\s+const\s*$/u, '').trim();
+}
+function unescapeSingleQuotedString(value) {
+    return value.replace(/\\(['"\\nrtbfv0])/gu, (_, sequence)=>{
+        switch(sequence){
+            case 'n':
+                return '\n';
+            case 'r':
+                return '\r';
+            case 't':
+                return '\t';
+            case 'b':
+                return '\b';
+            case 'f':
+                return '\f';
+            case 'v':
+                return '\v';
+            case '0':
+                return '\0';
+            default:
+                return sequence;
+        }
+    });
+}
+function parseLiteralString(source) {
+    if (void 0 === source) return;
+    const trimmed = stripConstAssertion(source);
+    const quote = trimmed[0];
+    if ("'" !== quote && '"' !== quote && '`' !== quote) return;
+    if ('`' === quote) {
+        if (trimmed.includes('${')) return;
+        const close = trimmed.lastIndexOf('`');
+        return close > 0 ? trimmed.slice(1, close).replaceAll('\\`', '`') : void 0;
+    }
+    const close = trimmed.lastIndexOf(quote);
+    if (close <= 0 || '' !== trimmed.slice(close + 1).trim()) return;
+    const content = trimmed.slice(1, close);
+    if ('"' === quote) try {
+        return JSON.parse(trimmed);
+    } catch  {
+        return;
+    }
+    return unescapeSingleQuotedString(content);
+}
+function parseObjectKey(source) {
+    const trimmed = source.trim();
+    const literal = parseLiteralString(trimmed);
+    if (void 0 !== literal) return literal;
+    return /^[$A-Z_a-z][$\w]*$/u.test(trimmed) ? trimmed : void 0;
+}
+function parseObjectLiteral(source) {
+    if (void 0 === source) return;
+    const block = getOuterBlock(source, '{', '}');
+    if (!block) return;
+    const properties = new Map();
+    let hasSpread = false;
+    for (const entry of splitTopLevelEntries(block.inner)){
+        if (entry.startsWith('...')) {
+            hasSpread = true;
+            continue;
+        }
+        const colon = findTopLevelColon(entry);
+        if (-1 === colon) {
+            hasSpread = true;
+            continue;
+        }
+        const key = parseObjectKey(entry.slice(0, colon));
+        if (void 0 === key) {
+            hasSpread = true;
+            continue;
+        }
+        properties.set(key, entry.slice(colon + 1).trim());
+    }
+    return {
+        hasSpread,
+        properties
+    };
+}
+function parseArrayLiteral(source) {
+    if (void 0 === source) return;
+    const block = getOuterBlock(source, '[', ']');
+    if (!block) return;
+    const entries = splitTopLevelEntries(block.inner);
+    const exposes = [];
+    for (const entry of entries){
+        const expose = parseLiteralString(entry);
+        if (void 0 === expose) return;
+        exposes.push(expose);
+    }
+    return exposes;
+}
+export { parseArrayLiteral, parseLiteralString, parseObjectLiteral };