@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/esm-node/ultramodern-workspace/public-api.js

@@ -0,0 +1,5 @@
+import "node:module";
+export { addUltramodernShell, planUltramodernShell } from "./add-shell.js";
+export { addUltramodernVertical, planUltramodernVertical } from "./add-vertical.js";
+export { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
+export { generateUltramodernWorkspace } from "./write-workspace.js";

package/dist/esm-node/ultramodern-workspace/public-surface.js

@@ -0,0 +1,184 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createRouteHeadModule } from "./app-files.js";
+import { relativeRootFor } from "./naming.js";
+import { createPublicHeadRobotsPolicy, createPublicSurfaceContentExpansionPolicy } from "./policy.js";
+import { createJsonLdHelperModule, createPublicRouteMetadata, createRouteAliasPage, createRouteMetaFilePath, createRouteMetaModule, createRouteMetadataModule, createRouteOwnedI18nPaths, createRoutePageFilePath, isConcretePublicPath, normalisePublicPath } from "./routes.js";
+import { supportedWorkspaceLanguages } from "./types.js";
+const publicSurfaceManagedSourceAssetPaths = [
+    'config/public/robots.txt',
+    'config/public/sitemap.xml',
+    'config/public/site.webmanifest'
+];
+const publicSurfaceBaseOutputFiles = [
+    'robots.txt'
+];
+const publicSurfacePublicRouteOutputFiles = [
+    'sitemap.xml',
+    'site.webmanifest'
+];
+function createLocalisedPublicPath(pathname, language) {
+    const publicPath = normalisePublicPath(pathname);
+    return '/' === publicPath ? `/${language}` : `/${language}${publicPath}`;
+}
+function uniqueSorted(values) {
+    return Array.from(new Set(values)).sort((left, right)=>left.localeCompare(right));
+}
+function createPublicSurfaceRouteEntries(app) {
+    return createPublicRouteMetadata(app).map((route)=>{
+        const localeUrlPaths = Object.fromEntries(supportedWorkspaceLanguages.map((language)=>[
+                language,
+                createLocalisedPublicPath(route.localisedPaths[language], language)
+            ]));
+        if (!Object.values(localeUrlPaths).every(isConcretePublicPath)) return;
+        return {
+            ...route,
+            canonicalUrlPath: localeUrlPaths.en,
+            localeUrlPaths
+        };
+    }).filter((route)=>void 0 !== route).sort((left, right)=>left.canonicalUrlPath.localeCompare(right.canonicalUrlPath) || left.id.localeCompare(right.id));
+}
+function createPublicSurfaceUrlPaths(app) {
+    return uniqueSorted(createPublicSurfaceRouteEntries(app).flatMap((route)=>supportedWorkspaceLanguages.map((language)=>route.localeUrlPaths[language])));
+}
+function createPublicSurfaceOutputFiles(app) {
+    return [
+        ...publicSurfaceBaseOutputFiles,
+        ...createPublicRouteMetadata(app).length > 0 ? publicSurfacePublicRouteOutputFiles : []
+    ];
+}
+function createPublicSurfaceGenerationCommand(app, target, requirePublicOrigin = false) {
+    return `node ${relativeRootFor(app.directory)}/scripts/generate-public-surface-assets.mts --app ${app.id} --target ${target}${requirePublicOrigin ? ' --require-public-origin' : ''}`;
+}
+function rewriteWorkspaceAssetsForApp(workspaceRoot, app) {
+    for (const relativePath of publicSurfaceManagedSourceAssetPaths)node_fs.rmSync(node_path.join(workspaceRoot, app.directory, relativePath), {
+        force: true
+    });
+}
+function createPublicSurfaceContract(app) {
+    const files = createPublicSurfaceOutputFiles(app);
+    const contentExpansionPolicy = createPublicSurfaceContentExpansionPolicy();
+    return {
+        authoring: 'colocated-route-meta',
+        artifactLifecycle: 'build-and-deploy-output',
+        generatedManifest: './src/routes/ultramodern-route-metadata',
+        source: 'route-owned-public-routes',
+        metadataExport: './src/routes/ultramodern-route-metadata',
+        generator: "scripts/generate-public-surface-assets.mts",
+        outputRoot: 'dist/public',
+        cloudflareBuildOutputRoot: 'dist-cloudflare/public',
+        privateRoutePolicy: 'omit-from-generated-public-surface',
+        files,
+        omittedByDefault: [
+            'api-catalog.json',
+            'llms.txt',
+            'security.txt'
+        ],
+        languages: [
+            ...supportedWorkspaceLanguages
+        ],
+        contentExpansion: {
+            authoring: 'route-owned-esm-provider',
+            defaultProviderFile: contentExpansionPolicy.defaultProviderFile,
+            entryExport: 'default-or-entries',
+            paramsSource: 'params-or-localeParams',
+            draftPolicy: contentExpansionPolicy.draftPolicy,
+            indexablePolicy: contentExpansionPolicy.indexablePolicy,
+            lifecycle: 'executed-during-public-surface-generation'
+        },
+        contentSources: [],
+        publicRoutes: createPublicRouteMetadata(app),
+        routeEntries: createPublicSurfaceRouteEntries(app),
+        concreteUrlPaths: createPublicSurfaceUrlPaths(app)
+    };
+}
+function createPublicHeadContract() {
+    const robotsPolicy = createPublicHeadRobotsPolicy();
+    return {
+        authoring: 'colocated-route-meta',
+        generator: './src/routes/ultramodern-route-head',
+        renderer: '@modern-js/runtime/head Helmet',
+        ssr: true,
+        title: {
+            required: true,
+            source: 'route.titleKey'
+        },
+        description: {
+            required: true,
+            source: "route.descriptionKey"
+        },
+        canonical: {
+            publicIndexableOnly: true,
+            source: 'localized canonical route URL'
+        },
+        alternates: {
+            hreflang: [
+                ...supportedWorkspaceLanguages
+            ],
+            xDefault: 'en'
+        },
+        openGraph: {
+            publicIndexableOnly: true,
+            required: [
+                'og:title',
+                "og:description",
+                'og:url',
+                'og:type'
+            ]
+        },
+        twitter: {
+            publicIndexableOnly: true,
+            required: [
+                'twitter:card',
+                'twitter:title',
+                "twitter:description"
+            ]
+        },
+        structuredData: {
+            publicIndexableOnly: true,
+            optional: true,
+            source: 'route.jsonLd',
+            inference: false,
+            helperModule: './src/routes/ultramodern-jsonld',
+            helperTypes: [
+                'WebPage',
+                'WebApplication',
+                'SoftwareApplication',
+                'BreadcrumbList',
+                'FAQPage',
+                'Organization'
+            ],
+            sanitizesHtmlOpenBracket: true
+        },
+        privateRouteRobots: robotsPolicy.privateRouteRobots
+    };
+}
+function createPublicWebAppArtifacts(app) {
+    const routeMetadata = createRouteOwnedI18nPaths(app);
+    return {
+        jsonLdHelperFile: {
+            path: `${app.directory}/src/routes/ultramodern-jsonld.ts`,
+            content: createJsonLdHelperModule()
+        },
+        routeMetadataFile: {
+            path: `${app.directory}/src/routes/ultramodern-route-metadata.ts`,
+            content: createRouteMetadataModule(app)
+        },
+        routeHeadFile: {
+            path: `${app.directory}/src/routes/ultramodern-route-head.tsx`,
+            content: createRouteHeadModule(app)
+        },
+        routeMetaFiles: routeMetadata.map((route)=>({
+                path: createRouteMetaFilePath(app, route.canonicalPath),
+                content: createRouteMetaModule(route)
+            })),
+        routeAliasFiles: routeMetadata.filter((route)=>'/' !== route.canonicalPath && 'shell' !== app.kind).map((route)=>({
+                path: createRoutePageFilePath(app, route.canonicalPath),
+                content: createRouteAliasPage(route.canonicalPath)
+            })),
+        publicHead: createPublicHeadContract(),
+        publicSurface: createPublicSurfaceContract(app)
+    };
+}
+export { createLocalisedPublicPath, createPublicSurfaceGenerationCommand, createPublicWebAppArtifacts, publicSurfaceManagedSourceAssetPaths, rewriteWorkspaceAssetsForApp, uniqueSorted };

package/dist/esm-node/ultramodern-workspace/routes.js

@@ -0,0 +1,147 @@
+import "node:module";
+import { appI18nNamespace } from "./descriptors.js";
+import { renderFileTemplate } from "./fs-io.js";
+import { sortJsonValue } from "./types.js";
+const privateAppRoutePublicness = {
+    indexable: false,
+    public: false,
+    publicSurface: 'private-app-screen'
+};
+function createRouteOwnedI18nPaths(app) {
+    const namespace = appI18nNamespace(app);
+    const base = {
+        descriptionKey: `${namespace}.seo.description`,
+        mfBoundaryId: app.mfName,
+        namespace,
+        ownerAppId: app.id,
+        ...privateAppRoutePublicness
+    };
+    if ('shell' === app.kind) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'shell-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'shell.title'
+        }
+    ];
+    return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: `${app.id}-home`,
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: `${namespace}.title`
+        }
+    ];
+}
+function isPublicIndexableRoute(route) {
+    return route.public && route.indexable;
+}
+function createLocalisedUrlsMapFromRoutes(routes) {
+    return Object.fromEntries(routes.flatMap((route)=>{
+        if ('/' === route.canonicalPath) return [];
+        return Array.from(new Set([
+            route.canonicalPath,
+            ...Object.values(route.localisedPaths)
+        ])).map((pathname)=>[
+                pathname,
+                route.localisedPaths
+            ]);
+    }));
+}
+function createLocalisedUrlsMap(app) {
+    return createLocalisedUrlsMapFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createPublicRouteMetadataFromRoutes(routes) {
+    return routes.filter(isPublicIndexableRoute).map((route)=>{
+        const metadata = {
+            canonicalPath: route.canonicalPath,
+            id: route.id,
+            localisedPaths: route.localisedPaths,
+            namespace: route.namespace,
+            ownerAppId: route.ownerAppId,
+            descriptionKey: route.descriptionKey,
+            titleKey: route.titleKey
+        };
+        if (void 0 !== route.jsonLd) metadata.jsonLd = route.jsonLd;
+        return metadata;
+    });
+}
+function createPublicRouteMetadata(app) {
+    return createPublicRouteMetadataFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createJsonLdHelperModule() {
+    return renderFileTemplate('workspace/apps/shared/src/routes/ultramodern-jsonld.ts', {});
+}
+function createRouteMetadataModule(app) {
+    const routes = sortJsonValue(createRouteOwnedI18nPaths(app));
+    const localisedUrls = sortJsonValue(createLocalisedUrlsMap(app));
+    const publicRoutes = sortJsonValue(createPublicRouteMetadata(app));
+    const namespace = appI18nNamespace(app);
+    return renderFileTemplate('workspace/apps/shared/src/routes/ultramodern-route-metadata.ts', {
+        value0: namespace,
+        value1: JSON.stringify(routes, null, 2),
+        value2: JSON.stringify(localisedUrls, null, 2),
+        value3: JSON.stringify(publicRoutes, null, 2)
+    });
+}
+function createRouteMetaModule(route) {
+    return `const routeMeta = ${JSON.stringify(sortJsonValue(route), null, 2)} as const;
+
+export default routeMeta;
+export { routeMeta };
+`;
+}
+function normalisePublicPath(pathname) {
+    const normalised = pathname.trim().replaceAll(/\/+/gu, '/').replace(/\/+$/u, '');
+    return normalised.length > 0 && normalised.startsWith('/') ? normalised : `/${normalised}`;
+}
+function splitPublicPathSegments(pathname) {
+    return normalisePublicPath(pathname).split('/').filter(Boolean);
+}
+function routePathParamName(segment) {
+    if (segment.startsWith(':')) return segment.slice(1).replace(/[?*+]$/u, '');
+    if (segment.startsWith('[') && segment.endsWith(']')) return segment.slice(1, -1).replace(/^\.\.\./u, '').replace(/\$$/u, '');
+}
+function isDynamicPublicPathSegment(segment) {
+    return void 0 !== routePathParamName(segment) || segment.includes('*') || segment.startsWith('[');
+}
+function isConcretePublicPath(pathname) {
+    return !splitPublicPathSegments(pathname).some(isDynamicPublicPathSegment);
+}
+function routeSegmentToDirectory(segment) {
+    const paramName = routePathParamName(segment);
+    if (paramName && segment.startsWith(':')) return segment.endsWith('?') ? `[${paramName}$]` : `[${paramName}]`;
+    return segment;
+}
+function routePathDirectorySegments(routePath) {
+    return splitPublicPathSegments(routePath).map(routeSegmentToDirectory);
+}
+function createRoutePageFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'page.tsx'
+    ].join('/')}`;
+}
+function createRouteMetaFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'route.meta.ts'
+    ].join('/')}`;
+}
+function createRouteAliasPage(canonicalPath) {
+    const depth = canonicalPath.split('/').filter(Boolean).length;
+    const rootPageImport = `${'../'.repeat(depth)}page`;
+    return `export { default } from '${rootPageImport}';
+`;
+}
+export { createJsonLdHelperModule, createLocalisedUrlsMap, createPublicRouteMetadata, createPublicRouteMetadataFromRoutes, createRouteAliasPage, createRouteMetaFilePath, createRouteMetaModule, createRouteMetadataModule, createRouteOwnedI18nPaths, createRoutePageFilePath, isConcretePublicPath, normalisePublicPath, routePathParamName, routeSegmentToDirectory, splitPublicPathSegments };

package/dist/esm-node/ultramodern-workspace/shared-patches.js

@@ -0,0 +1,4 @@
+import "node:module";
+import { ULTRAMODERN_WORKSPACE_POLICY } from "./policy.js";
+const SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES = ULTRAMODERN_WORKSPACE_POLICY.pnpm.patchedDependencies.required.map((patch)=>patch.path.replace(/^patches\//u, '')).filter((patchFile)=>patchFile.startsWith('@module-federation__') || patchFile.startsWith('@tanstack__') || patchFile.startsWith('msgpackr@') || patchFile.startsWith('zod@'));
+export { SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES };

package/dist/esm-node/ultramodern-workspace/shells.js

@@ -0,0 +1,97 @@
+import "node:module";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
+import { createModuleFederationRemoteContracts, createNeutralOwnership, shellApp } from "./descriptors.js";
+import { packageName, toEnvSegment, toKebabCase, toPascalCase } from "./naming.js";
+import { resolveOwnerAttribution } from "./types.js";
+const PRIMARY_SHELL_ID = shellApp.id;
+const FIRST_ADDITIONAL_SHELL_PORT = 3120;
+function createShellDescriptor(name, port) {
+    const normalized = toKebabCase(name);
+    const id = `shell-${normalized}`;
+    const displayPrefix = toPascalCase(normalized).replace(/([a-z])([A-Z])/g, '$1 $2');
+    return {
+        id,
+        directory: `apps/${id}`,
+        packageSuffix: id,
+        displayName: `${displayPrefix} Shell`,
+        kind: 'shell',
+        portEnv: `SHELL_${toEnvSegment(normalized)}_PORT`,
+        port,
+        mfName: `shell${toPascalCase(normalized)}`,
+        verticalRefs: [],
+        ownership: createNeutralOwnership(id, 'tier-0-shell')
+    };
+}
+function assertValidShellName(name) {
+    const normalized = toKebabCase(name);
+    if (!normalized || normalized !== name) throw new Error(`Invalid Shell name "${name}". Use lowercase kebab-case.`);
+    if (`shell-${normalized}` === PRIMARY_SHELL_ID || 'super-app' === normalized) throw new Error(`Shell name "${name}" is reserved for the primary shell (${PRIMARY_SHELL_ID}).`);
+    return normalized;
+}
+function shellDeliveryUnitBlock(scope, shell) {
+    return shell.deliveryUnit ?? deliveryUnitContractBlock(createDeliveryUnitRecord(scope, shell));
+}
+function createAdditionalShellConfigEntry(scope, shell, remotes = []) {
+    const verticalRefs = shell.verticalRefs ?? [];
+    return {
+        id: shell.id,
+        name: shell.id.replace(/^shell-/u, ''),
+        kind: 'shell',
+        package: packageName(scope, shell.packageSuffix),
+        path: shell.directory,
+        port: shell.port,
+        portEnv: shell.portEnv,
+        mfName: shell.mfName,
+        verticalRefs,
+        owner: resolveOwnerAttribution(shell.ownership),
+        deliveryUnit: shellDeliveryUnitBlock(scope, shell),
+        moduleFederation: {
+            role: 'host',
+            name: shell.mfName,
+            verticalRefs,
+            remotes: createModuleFederationRemoteContracts(shell, remotes),
+            ssr: true,
+            sharedContractVersion: 'mf-ssr-contract-v1'
+        }
+    };
+}
+function resolveConfiguredAdditionalShells(config) {
+    const shells = config?.shells;
+    if (!Array.isArray(shells)) return [];
+    return shells.filter((entry)=>null !== entry && 'object' == typeof entry && !Array.isArray(entry)).map((entry)=>{
+        const id = String(entry.id ?? '');
+        const suffix = 'string' == typeof entry.package ? entry.package.split('/').at(-1) ?? id : id;
+        const name = 'string' == typeof entry.name ? entry.name : id.replace(/^shell-/, '');
+        const port = 'number' == typeof entry.port ? entry.port : FIRST_ADDITIONAL_SHELL_PORT;
+        const descriptor = createShellDescriptor(name, port);
+        const moduleFederation = entry.moduleFederation && 'object' == typeof entry.moduleFederation && !Array.isArray(entry.moduleFederation) ? entry.moduleFederation : void 0;
+        const owner = entry.owner;
+        const deliveryUnit = entry.deliveryUnit;
+        const ownerAttribution = owner && 'object' == typeof owner && !Array.isArray(owner) && 'kind' in owner && ('team' === owner.kind || 'agent' === owner.kind || 'agent-team' === owner.kind) && 'id' in owner && 'string' == typeof owner.id ? {
+            kind: owner.kind,
+            id: owner.id,
+            ...'contact' in owner && 'string' == typeof owner.contact ? {
+                contact: owner.contact
+            } : {}
+        } : void 0;
+        const ownership = void 0 === ownerAttribution ? descriptor.ownership : {
+            ...descriptor.ownership,
+            owner: ownerAttribution
+        };
+        return {
+            ...descriptor,
+            id,
+            packageSuffix: suffix,
+            ownership,
+            displayName: 'string' == typeof entry.displayName ? entry.displayName : descriptor.displayName,
+            directory: 'string' == typeof entry.path ? entry.path : descriptor.directory,
+            portEnv: 'string' == typeof entry.portEnv ? entry.portEnv : descriptor.portEnv,
+            mfName: 'string' == typeof entry.mfName ? entry.mfName : 'string' == typeof moduleFederation?.name ? moduleFederation.name : descriptor.mfName,
+            verticalRefs: Array.isArray(entry.verticalRefs) ? entry.verticalRefs.filter((ref)=>'string' == typeof ref) : Array.isArray(moduleFederation?.verticalRefs) ? moduleFederation.verticalRefs.filter((ref)=>'string' == typeof ref) : [],
+            ...deliveryUnit && 'object' == typeof deliveryUnit && !Array.isArray(deliveryUnit) ? {
+                deliveryUnit: deliveryUnit
+            } : {}
+        };
+    });
+}
+export { FIRST_ADDITIONAL_SHELL_PORT, PRIMARY_SHELL_ID, assertValidShellName, createAdditionalShellConfigEntry, createShellDescriptor, resolveConfiguredAdditionalShells, shellDeliveryUnitBlock };

package/dist/esm-node/ultramodern-workspace/tooling-command-catalog.js

@@ -0,0 +1,101 @@
+import "node:module";
+const defineToolingCommand = (command)=>({
+        ...command,
+        wrapperPath: `scripts/${command.wrapperName}.mts`
+    });
+const generatedToolingCommands = [
+    defineToolingCommand({
+        id: 'validate',
+        command: 'validate',
+        wrapperName: 'validate-ultramodern-workspace',
+        contractKey: 'validate',
+        rootScript: 'contract:check'
+    }),
+    defineToolingCommand({
+        id: 'typecheck',
+        command: 'typecheck',
+        wrapperName: 'ultramodern-typecheck',
+        contractKey: 'typecheck',
+        rootScript: 'typecheck',
+        templatePath: "templates/workspace-scripts/ultramodern-typecheck.mjs",
+        cwd: 'invocation'
+    }),
+    defineToolingCommand({
+        id: 'mfTypes',
+        command: 'mf-types',
+        wrapperName: 'assert-mf-types',
+        contractKey: 'mfTypes',
+        rootScript: 'mf:types'
+    }),
+    defineToolingCommand({
+        id: 'publicSurface',
+        command: 'public-surface',
+        wrapperName: 'generate-public-surface-assets',
+        contractKey: 'publicSurface',
+        templatePath: "templates/workspace-scripts/generate-public-surface-assets.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationGenerate',
+        command: 'backend-federation-generate',
+        wrapperName: 'generate-node-backend-federation',
+        contractKey: 'backendFederationGenerate',
+        rootScript: 'node:backend-federation:generate',
+        templatePath: "templates/workspace-scripts/generate-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationProof',
+        command: 'backend-federation-proof',
+        wrapperName: 'proof-node-backend-federation',
+        contractKey: 'backendFederationProof',
+        rootScript: 'node:proof',
+        templatePath: "templates/workspace-scripts/proof-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareProof',
+        command: 'cloudflare-proof',
+        wrapperName: 'proof-cloudflare-version',
+        contractKey: 'cloudflareProof',
+        rootScript: 'cloudflare:proof',
+        templatePath: "templates/workspace-scripts/proof-cloudflare-version.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareOutputVerify',
+        command: 'cloudflare-output-verify',
+        wrapperName: 'verify-cloudflare-output',
+        contractKey: 'cloudflareOutputVerify',
+        rootScript: 'cloudflare-output:verify'
+    }),
+    defineToolingCommand({
+        id: 'performanceReadiness',
+        command: 'performance-readiness',
+        wrapperName: 'ultramodern-performance-readiness',
+        contractKey: 'performanceReadiness',
+        rootScript: 'performance:readiness',
+        templatePath: "templates/workspace-scripts/ultramodern-performance-readiness.mjs"
+    }),
+    defineToolingCommand({
+        id: 'migrateStrictEffect',
+        command: 'migrate-strict-effect',
+        wrapperName: 'migrate-strict-effect',
+        contractKey: 'migrateStrictEffect',
+        rootScript: 'migrate:strict-effect'
+    }),
+    defineToolingCommand({
+        id: 'routesGenerate',
+        command: 'routes-generate',
+        wrapperName: 'generate-tanstack-routes',
+        contractKey: 'routesGenerate'
+    })
+];
+const toolingCommandById = Object.fromEntries(generatedToolingCommands.map((command)=>[
+        command.id,
+        command
+    ]));
+const GENERATED_TOOLING_COMMANDS = toolingCommandById;
+const generatedToolingCommandList = ()=>generatedToolingCommands.map((command)=>command.command);
+const createToolingWrapperContract = ()=>Object.fromEntries(generatedToolingCommands.map((command)=>[
+            command.contractKey,
+            command.wrapperPath
+        ]));
+const createGeneratedToolingWrapperMap = createToolingWrapperContract;
+export { GENERATED_TOOLING_COMMANDS, createGeneratedToolingWrapperMap, generatedToolingCommandList, generatedToolingCommands };

package/dist/esm-node/ultramodern-workspace/tsconfigs.js

@@ -0,0 +1,139 @@
+import "node:module";
+import node_path from "node:path";
+import { appHasApi, resolveRemoteRefs, sharedPackages } from "./descriptors.js";
+import { effectDiagnostics } from "./effect-diagnostics.js";
+import { relativeRootFor } from "./naming.js";
+function createTsConfigBase() {
+    return {
+        compilerOptions: {
+            target: 'ESNext',
+            lib: [
+                'ESNext',
+                'DOM',
+                'DOM.Iterable'
+            ],
+            module: 'preserve',
+            moduleResolution: 'Bundler',
+            moduleDetection: 'force',
+            jsx: 'preserve',
+            isolatedModules: true,
+            verbatimModuleSyntax: true,
+            strict: true,
+            noEmit: true,
+            allowImportingTsExtensions: true,
+            allowJs: true,
+            esModuleInterop: true,
+            noUncheckedIndexedAccess: true,
+            exactOptionalPropertyTypes: true,
+            noImplicitOverride: true,
+            noFallthroughCasesInSwitch: true,
+            noPropertyAccessFromIndexSignature: true,
+            noImplicitReturns: true,
+            resolveJsonModule: true,
+            plugins: [
+                {
+                    name: '@effect/language-service',
+                    diagnostics: true,
+                    includeSuggestionsInTsc: true,
+                    ignoreEffectSuggestionsInTscExitCode: false,
+                    ignoreEffectWarningsInTscExitCode: false,
+                    ignoreEffectErrorsInTscExitCode: false,
+                    skipDisabledOptimization: true,
+                    diagnosticSeverity: Object.fromEntries(effectDiagnostics.map((name)=>[
+                            name,
+                            'error'
+                        ]))
+                }
+            ]
+        }
+    };
+}
+function createTsBuildInfoFile(packageDir) {
+    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
+    return `${relativeRootFor(packageDir)}/node_modules/.cache/tsgo/${cacheKey}.tsbuildinfo`;
+}
+function createTsDeclarationOutDir(packageDir) {
+    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
+    return `${relativeRootFor(packageDir)}/node_modules/.cache/tsgo/declarations/${cacheKey}`;
+}
+function createReferences(packageDir, references) {
+    return [
+        ...new Set(references)
+    ].filter((reference)=>reference !== packageDir).map((reference)=>({
+            path: node_path.relative(packageDir, reference).split(node_path.sep).join('/')
+        }));
+}
+function createPackageTsConfig(packageDir, options = {}) {
+    const resolvedOptions = 'boolean' == typeof options ? {
+        includeApi: options
+    } : options;
+    const include = resolvedOptions.include ?? [
+        'src',
+        'locales/**/*.json',
+        'package.json',
+        'shared'
+    ];
+    if (resolvedOptions.includeServer) include.push('server');
+    if (resolvedOptions.includeApi) include.push('api');
+    const references = createReferences(packageDir, resolvedOptions.references ?? []);
+    const tsconfig = {
+        extends: `${relativeRootFor(packageDir)}/tsconfig.base.json`,
+        compilerOptions: {
+            composite: true,
+            declaration: true,
+            declarationMap: false,
+            emitDeclarationOnly: true,
+            incremental: true,
+            noEmit: false,
+            outDir: createTsDeclarationOutDir(packageDir),
+            tsBuildInfoFile: createTsBuildInfoFile(packageDir)
+        },
+        include
+    };
+    if (references.length > 0) tsconfig.references = references;
+    return tsconfig;
+}
+function createAppTsConfig(app, remotes = []) {
+    const references = [
+        ...sharedPackages.map((sharedPackage)=>sharedPackage.directory),
+        ...'shell' === app.kind ? [] : resolveRemoteRefs(app, remotes).map((remote)=>remote.directory)
+    ];
+    return createPackageTsConfig(app.directory, {
+        includeApi: appHasApi(app),
+        includeServer: true,
+        references
+    });
+}
+function createAppMfTypesTsConfig(app) {
+    const exposedFiles = Object.entries(app.exposes ?? {}).sort(([left], [right])=>'./Route' === left ? -1 : './Route' === right ? 1 : 0).map(([, exposePath])=>exposePath.replace(/^\.\//u, ''));
+    return {
+        extends: `${relativeRootFor(app.directory)}/tsconfig.base.json`,
+        include: [
+            ...new Set([
+                ...exposedFiles,
+                'src/modern-app-env.d.ts'
+            ])
+        ]
+    };
+}
+function createSharedPackageTsConfig(packageDir) {
+    return createPackageTsConfig(packageDir, {
+        include: [
+            'src'
+        ]
+    });
+}
+function createRootTsConfig(apps = []) {
+    return {
+        files: [],
+        references: [
+            ...sharedPackages.map((sharedPackage)=>({
+                    path: sharedPackage.directory
+                })),
+            ...apps.map((app)=>({
+                    path: app.directory
+                }))
+        ]
+    };
+}
+export { createAppMfTypesTsConfig, createAppTsConfig, createPackageTsConfig, createRootTsConfig, createSharedPackageTsConfig, createTsConfigBase };