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

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

@@ -66,7 +66,7 @@ function createPublicSurfaceContract(app) {
         metadataExport: './src/routes/ultramodern-route-metadata',
         generator: "scripts/generate-public-surface-assets.mts",
         outputRoot: 'dist/public',
-        cloudflareOutputRoot: '.output/public',
+        cloudflareBuildOutputRoot: 'dist-cloudflare/public',
         privateRoutePolicy: 'omit-from-generated-public-surface',
         files,
         omittedByDefault: [
@@ -180,4 +180,4 @@ function createPublicWebAppArtifacts(app) {
         publicSurface: createPublicSurfaceContract(app)
     };
 }
-export { createLocalisedPublicPath, createPublicHeadContract, createPublicSurfaceContract, createPublicSurfaceGenerationCommand, createPublicSurfaceOutputFiles, createPublicSurfaceRouteEntries, createPublicSurfaceUrlPaths, createPublicWebAppArtifacts, publicSurfaceBaseOutputFiles, publicSurfaceManagedSourceAssetPaths, publicSurfacePublicRouteOutputFiles, rewriteWorkspaceAssetsForApp, uniqueSorted };
+export { createLocalisedPublicPath, createPublicSurfaceGenerationCommand, createPublicWebAppArtifacts, publicSurfaceManagedSourceAssetPaths, rewriteWorkspaceAssetsForApp, uniqueSorted };

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

@@ -1,4 +1,5 @@
 import { appI18nNamespace } from "./descriptors.js";
+import { renderFileTemplate } from "./fs-io.js";
 import { sortJsonValue } from "./types.js";
 const privateAppRoutePublicness = {
     indexable: false,
@@ -76,154 +77,19 @@ function createPublicRouteMetadata(app) {
     return createPublicRouteMetadataFromRoutes(createRouteOwnedI18nPaths(app));
 }
 function createJsonLdHelperModule() {
-    return `export type JsonLdPrimitive = string | number | boolean | null;
-export type JsonLdValue =
-  | JsonLdPrimitive
-  | readonly JsonLdValue[]
-  | { readonly [key: string]: JsonLdValue };
-export type JsonLdObject = Readonly<Record<string, JsonLdValue>>;
-export type RouteJsonLd = JsonLdObject | readonly JsonLdObject[];
-
-const schemaContext = 'https://schema.org' as const;
-
-type SchemaObject<TType extends string> = JsonLdObject & {
-  readonly '@context': typeof schemaContext;
-  readonly '@type': TType;
-};
-
-type ThingReference =
-  | string
-  | {
-      readonly '@id'?: string;
-      readonly '@type'?: string;
-      readonly name?: string;
-      readonly url?: string;
-    };
-
-const withSchemaContext = <TType extends string, TInput extends object>(
-  type: TType,
-  input: TInput,
-): SchemaObject<TType> & TInput => ({
-  '@context': schemaContext,
-  '@type': type,
-  ...input,
-});
-
-export const defineRouteJsonLd = <TJsonLd extends RouteJsonLd>(
-  jsonLd: TJsonLd,
-): TJsonLd => jsonLd;
-
-export interface WebPageJsonLdInput {
-  readonly name: string;
-  readonly url: string;
-  readonly description?: string;
-  readonly inLanguage?: string | readonly string[];
-  readonly isPartOf?: ThingReference;
-}
-
-export const webPageJsonLd = (input: WebPageJsonLdInput) =>
-  withSchemaContext('WebPage', input);
-
-export interface WebApplicationJsonLdInput {
-  readonly name: string;
-  readonly url: string;
-  readonly applicationCategory?: string;
-  readonly browserRequirements?: string;
-  readonly description?: string;
-  readonly operatingSystem?: string;
-}
-
-export const webApplicationJsonLd = (input: WebApplicationJsonLdInput) =>
-  withSchemaContext('WebApplication', input);
-
-export interface SoftwareApplicationJsonLdInput {
-  readonly name: string;
-  readonly url: string;
-  readonly applicationCategory?: string;
-  readonly applicationSubCategory?: string;
-  readonly description?: string;
-  readonly offers?: ThingReference;
-  readonly operatingSystem?: string;
-}
-
-export const softwareApplicationJsonLd = (
-  input: SoftwareApplicationJsonLdInput,
-) => withSchemaContext('SoftwareApplication', input);
-
-export interface OrganizationJsonLdInput {
-  readonly name: string;
-  readonly url?: string;
-  readonly logo?: string;
-  readonly sameAs?: readonly string[];
-}
-
-export const organizationJsonLd = (input: OrganizationJsonLdInput) =>
-  withSchemaContext('Organization', input);
-
-export interface BreadcrumbListItemInput {
-  readonly name: string;
-  readonly item: string;
-}
-
-export const breadcrumbListJsonLd = (
-  items: readonly BreadcrumbListItemInput[],
-) =>
-  withSchemaContext('BreadcrumbList', {
-    itemListElement: items.map((entry, index) => ({
-      '@type': 'ListItem',
-      item: entry.item,
-      name: entry.name,
-      position: index + 1,
-    })),
-  });
-
-export interface FAQPageQuestionInput {
-  readonly name: string;
-  readonly acceptedAnswer: {
-    readonly text: string;
-  };
-}
-
-export const faqPageJsonLd = (questions: readonly FAQPageQuestionInput[]) =>
-  withSchemaContext('FAQPage', {
-    mainEntity: questions.map(question => ({
-      '@type': 'Question',
-      acceptedAnswer: {
-        '@type': 'Answer',
-        text: question.acceptedAnswer.text,
-      },
-      name: question.name,
-    })),
-  });
-`;
+    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 `// @generated by @modern-js/create.
-// Author route metadata in colocated src/routes/**/route.meta.ts files.
-// This compatibility manifest is regenerated from route-owned metadata.
-
-export const ultramodernRouteNamespace = '${namespace}' as const;
-
-export const ultramodernRouteMetadata = ${JSON.stringify(routes, null, 2)} as const;
-
-export const ultramodernLocalisedUrls = ${JSON.stringify(localisedUrls, null, 2)} as const;
-
-export const ultramodernPublicRoutes = ${JSON.stringify(publicRoutes, null, 2)} as const;
-
-export const ultramodernRouteConfig = {
-  authoring: 'colocated-route-meta',
-  generatedManifest: true,
-  localisedUrls: ultramodernLocalisedUrls,
-  namespace: ultramodernRouteNamespace,
-  publicRoutes: ultramodernPublicRoutes,
-  routes: ultramodernRouteMetadata,
-  source: 'route-owned',
-} as const;
-`;
+    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;
@@ -277,4 +143,4 @@ function createRouteAliasPage(canonicalPath) {
     return `export { default } from '${rootPageImport}';
 `;
 }
-export { createJsonLdHelperModule, createLocalisedUrlsMap, createLocalisedUrlsMapFromRoutes, createPublicRouteMetadata, createPublicRouteMetadataFromRoutes, createRouteAliasPage, createRouteMetaFilePath, createRouteMetaModule, createRouteMetadataModule, createRouteOwnedI18nPaths, createRoutePageFilePath, isConcretePublicPath, isDynamicPublicPathSegment, isPublicIndexableRoute, normalisePublicPath, privateAppRoutePublicness, routePathDirectorySegments, routePathParamName, routeSegmentToDirectory, splitPublicPathSegments };
+export { createJsonLdHelperModule, createLocalisedUrlsMap, createPublicRouteMetadata, createPublicRouteMetadataFromRoutes, createRouteAliasPage, createRouteMetaFilePath, createRouteMetaModule, createRouteMetadataModule, createRouteOwnedI18nPaths, createRoutePageFilePath, isConcretePublicPath, normalisePublicPath, routePathParamName, routeSegmentToDirectory, splitPublicPathSegments };

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

@@ -0,0 +1,3 @@
+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__'));
+export { SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES };

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

@@ -0,0 +1,92 @@
+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 isPrimaryShell(shell) {
+    return shell.id === PRIMARY_SHELL_ID;
+}
+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 ownership = owner && 'object' == typeof owner && !Array.isArray(owner) && ('team' === owner.kind || 'agent' === owner.kind || 'agent-team' === owner.kind) && 'string' == typeof owner.id ? {
+            ...descriptor.ownership,
+            owner
+        } : descriptor.ownership;
+        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, isPrimaryShell, resolveConfiguredAdditionalShells, shellDeliveryUnitBlock };

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

@@ -0,0 +1,100 @@
+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/ultramodern-workspace/tsconfigs.js

@@ -0,0 +1,137 @@
+import node_path from "node:path";
+import { appHasApi, resolveRemoteRefs, sharedPackages, verticalApiApps } 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.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 appRemotes = resolveRemoteRefs(app, remotes);
+    const references = [
+        ...sharedPackages.map((sharedPackage)=>sharedPackage.directory),
+        ...'shell' === app.kind ? verticalApiApps(appRemotes).map((remote)=>remote.directory) : appRemotes.map((remote)=>remote.directory)
+    ];
+    return createPackageTsConfig(app.directory, {
+        includeApi: appHasApi(app),
+        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 };

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

@@ -6,6 +6,21 @@ function sortJsonValue(value) {
         ]));
     return value;
 }
+function isVerticalPreset(value) {
+    return 'full-stack' === value || 'api-only' === value || 'ui-only' === value;
+}
+function isVerticalApiProtocol(value) {
+    return 'rest' === value || 'rpc' === value;
+}
+function isWorkspaceDeliveryUnitKind(value) {
+    return 'microvertical' === value || 'horizontal-remote' === value;
+}
+function resolveOwnerAttribution(ownership) {
+    return ownership.owner ?? {
+        kind: 'team',
+        id: ownership.team
+    };
+}
 const supportedWorkspaceLanguages = [
     'en',
     'cs'
@@ -13,4 +28,4 @@ const supportedWorkspaceLanguages = [
 function isRecord(value) {
     return null !== value && 'object' == typeof value && !Array.isArray(value);
 }
-export { isRecord, sortJsonValue, supportedWorkspaceLanguages };
+export { isRecord, isVerticalApiProtocol, isVerticalPreset, isWorkspaceDeliveryUnitKind, resolveOwnerAttribution, sortJsonValue, supportedWorkspaceLanguages };

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

@@ -1,41 +1,50 @@
-const TANSTACK_ROUTER_VERSION = '1.170.16';
-const TANSTACK_ROUTER_CORE_VERSION = '1.171.13';
-const MODULE_FEDERATION_VERSION = '2.6.0';
+const TANSTACK_ROUTER_VERSION = '1.170.17';
+const TANSTACK_ROUTER_CORE_VERSION = '1.171.14';
+const MODULE_FEDERATION_VERSION = '2.8.0';
 const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.1.1';
 const ZEPHYR_AGENT_VERSION = '1.1.1';
-const WRANGLER_VERSION = '4.102.0';
+const WRANGLER_VERSION = '4.110.0';
 const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
-const TAILWIND_VERSION = '4.3.1';
-const TAILWIND_POSTCSS_VERSION = '4.3.1';
-const POSTCSS_VERSION = '8.5.15';
-const EFFECT_VERSION = '4.0.0-beta.91';
-const EFFECT_VITEST_VERSION = '4.0.0-beta.91';
-const EFFECT_TSGO_VERSION = '0.14.6';
-const TYPESCRIPT_STABLE_VERSION = '6.0.3';
-const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260628.1';
+const TAILWIND_VERSION = '4.3.2';
+const RSBUILD_PLUGIN_TAILWINDCSS_VERSION = '2.0.3';
+const EFFECT_VERSION = '4.0.0-beta.97';
+const EFFECT_VITEST_VERSION = '4.0.0-beta.97';
+const EFFECT_TSGO_VERSION = '0.19.0';
+const DRIZZLE_ORM_VERSION = '1.0.0-rc.4';
+const TYPESCRIPT_STABLE_VERSION = '7.0.2';
 const TYPESCRIPT_VERSION = TYPESCRIPT_STABLE_VERSION;
-const OXLINT_VERSION = '1.71.0';
-const OXFMT_VERSION = '0.56.0';
-const ULTRACITE_VERSION = '7.8.3';
-const LEFTHOOK_VERSION = '^2.1.9';
-const I18NEXT_VERSION = '26.3.1';
+const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260707.2';
+const OXLINT_VERSION = '1.73.0';
+const OXFMT_VERSION = '0.58.0';
+const ULTRACITE_VERSION = '7.9.3';
+const LEFTHOOK_VERSION = '^2.1.10';
+const I18NEXT_VERSION = '26.3.6';
+const MODULE_FEDERATION_NODE_VERSION = '2.7.47';
+const MINIFLARE_VERSION = '4.20260708.1';
+const WORKERD_VERSION = '1.20260708.1';
+const CLOUDFLARE_WORKERS_TYPES_VERSION = '5.20260710.1';
 const NODE_FETCH_VERSION = '^3.3.2';
-const REACT_VERSION = '^19.2.7';
-const REACT_DOM_VERSION = '^19.2.7';
-const REACT_ROUTER_VERSION = '7.18.0';
+const REACT_VERSION = '19.2.7';
+const REACT_DOM_VERSION = '19.2.7';
+const REACT_ROUTER_VERSION = '7.18.1';
 const TYPES_REACT_VERSION = '^19.2.17';
 const TYPES_REACT_DOM_VERSION = '^19.2.3';
-const NODE_VERSION = '26.3.0';
-const PNPM_VERSION = '11.9.0';
-const RSTACK_AGENT_SKILLS_COMMIT = '61c948b42512e223bad44b83af4080eba48b2677';
-const MODULE_FEDERATION_AGENT_SKILLS_COMMIT = '07bb5b6c43ad457609e00c081b72d4c42508ec76';
+const NODE_VERSION = '26.5.0';
+const PNPM_VERSION = '11.17.0';
 const ultramodernWorkspaceVersions = {
     tanstackRouter: TANSTACK_ROUTER_VERSION,
     tanstackRouterCore: TANSTACK_ROUTER_CORE_VERSION,
     moduleFederation: MODULE_FEDERATION_VERSION,
     effect: EFFECT_VERSION,
     effectVitest: EFFECT_VITEST_VERSION,
+    drizzleOrm: DRIZZLE_ORM_VERSION,
+    typescript: TYPESCRIPT_VERSION,
+    typescriptNativePreview: TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+    moduleFederationNode: MODULE_FEDERATION_NODE_VERSION,
+    miniflare: MINIFLARE_VERSION,
+    workerd: WORKERD_VERSION,
+    cloudflareWorkersTypes: CLOUDFLARE_WORKERS_TYPES_VERSION,
     tailwind: TAILWIND_VERSION,
-    tailwindPostcss: TAILWIND_POSTCSS_VERSION
+    rsbuildPluginTailwindcss: RSBUILD_PLUGIN_TAILWINDCSS_VERSION
 };
-export { CLOUDFLARE_COMPATIBILITY_DATE, EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_AGENT_SKILLS_COMMIT, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, NODE_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, POSTCSS_VERSION, REACT_DOM_VERSION, REACT_ROUTER_VERSION, REACT_VERSION, RSTACK_AGENT_SKILLS_COMMIT, TAILWIND_POSTCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_STABLE_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION, ultramodernWorkspaceVersions };
+export { CLOUDFLARE_COMPATIBILITY_DATE, CLOUDFLARE_WORKERS_TYPES_VERSION, DRIZZLE_ORM_VERSION, EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MINIFLARE_VERSION, MODULE_FEDERATION_NODE_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, NODE_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, REACT_DOM_VERSION, REACT_ROUTER_VERSION, REACT_VERSION, RSBUILD_PLUGIN_TAILWINDCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_STABLE_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WORKERD_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION, ultramodernWorkspaceVersions };