@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-entry.001-bootstrap-security.mjs

@@ -0,0 +1,22 @@
+const MODERN_WORKER_MANIFEST = p_workerManifest;
+p_workerModuleLoaders;
+new Map();
+new Map();
+new Map();
+const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
+CORS_POLICY.assets;
+(CORS_POLICY.allowedOrigins || []).map((origin)=>String(origin).toLowerCase());
+(CORS_POLICY.allowedMethods?.length ? CORS_POLICY.allowedMethods : [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'OPTIONS'
+]).join(', ');
+(CORS_POLICY.allowedHeaders?.length ? CORS_POLICY.allowedHeaders : [
+    '*'
+]).join(', ');
+globalThis.__dirname ??= '/';
+globalThis.__filename ??= '/index.js';

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-entry.006-fetch-handler.mjs

@@ -0,0 +1,32 @@
+export default {
+    async fetch (request, env, ctx) {
+        const corsPreflightResponse = await createCorsPreflightResponse(request, env);
+        if (corsPreflightResponse) return finalizeResponseForRequest(corsPreflightResponse, request);
+        const bffResponse = await dispatchBffRequest(request, env);
+        if (bffResponse) return finalizeResponseForRequest(withAppCorsHeaders(bffResponse, request), request);
+        const serviceBindingResponse = await dispatchServiceBindingRequest(request, env);
+        if (serviceBindingResponse) return finalizeResponseForRequest(withAppCorsHeaders(serviceBindingResponse, request), request);
+        const route = findRoute(request);
+        const { pathname } = new URL(request.url);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) {
+            const assetResponse = await fetchAsset(request, env);
+            if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+            return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+                status: 404
+            }), request), request);
+        }
+        const localeRedirectResponse = createLocaleRedirectResponseForRequest(route, request);
+        if (localeRedirectResponse) return finalizeResponseForRequest(withAppCorsHeaders(localeRedirectResponse, request), request);
+        if (route?.worker) {
+            const renderableRequest = createRenderableRequest(request);
+            return finalizeResponseForRequest(withAppCorsHeaders(await dispatchRouteWorker(route, renderableRequest, env, ctx), request), request);
+        }
+        const htmlResponse = await fetchRouteHtml(route, request, env);
+        if (htmlResponse) return finalizeResponseForRequest(htmlResponse, request);
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+        return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+            status: 404
+        }), request), request);
+    }
+};

package/dist/esm/plugins/backend-federation/codegen.mjs

@@ -0,0 +1,157 @@
+import node_path from "node:path";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/utils/universal";
+import { normalizeRelativePath } from "./config.mjs";
+const createRelativeImportSpecifier = (fromDirectory, toFile)=>{
+    const relativePath = normalizeRelativePath(node_path.relative(fromDirectory, toFile));
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+};
+const createPublicPath = (containerEntry, fallbackPort)=>{
+    try {
+        return new URL('.', containerEntry).href;
+    } catch  {
+        const slashIndex = containerEntry.lastIndexOf('/');
+        if (slashIndex >= 0) return containerEntry.slice(0, slashIndex + 1);
+        return `http://localhost:${fallbackPort}/`;
+    }
+};
+const createBackendRemoteEntrySource = (workspaceRoot, app, effectApiPath, entryPath)=>{
+    const effectApiSpecifier = createRelativeImportSpecifier(node_path.dirname(entryPath), effectApiPath);
+    return `// Generated by Modern.js backend federation build.
+const exposedModules = {
+  ${JSON.stringify(BACKEND_FEDERATION_EFFECT_EXPOSE)}: () =>
+    import(new URL(${JSON.stringify(effectApiSpecifier)}, import.meta.url).href),
+};
+
+export const __modernjsBackendFederation = ${JSON.stringify({
+        buildVersion: app.buildVersion,
+        expose: BACKEND_FEDERATION_EFFECT_EXPOSE,
+        name: app.backendName,
+        packageName: app.packageName,
+        remoteType: app.remoteType,
+        source: normalizeRelativePath(node_path.relative(workspaceRoot, effectApiPath)),
+        version: app.version,
+        ...app.unitId ? {
+            unitId: app.unitId
+        } : {},
+        ...app.sourceRevision ? {
+            sourceRevision: app.sourceRevision
+        } : {}
+    }, null, 2)};
+
+export function init() {}
+
+export function get(id) {
+  const load = exposedModules[id];
+  if (!load) {
+    throw new Error(\`Unexpected backend federation expose: \${id}\`);
+  }
+
+  return async () => load();
+}
+
+export default { get, init };
+`;
+};
+const createBackendManifest = (workspaceRoot, distDirectory, app)=>{
+    const sourceModule = `${app.directory}/api/effect-api.ts`;
+    const publicPath = createPublicPath(app.containerEntry, app.port);
+    const manifest = {
+        schemaVersion: 1,
+        id: app.backendName,
+        name: app.backendName,
+        version: app.version,
+        buildVersion: app.buildVersion,
+        metaData: {
+            name: app.backendName,
+            type: 'backend',
+            buildInfo: {
+                buildVersion: app.buildVersion,
+                buildName: app.packageName
+            },
+            remoteEntry: {
+                name: BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            globalName: app.backendName,
+            publicPath,
+            ssrRemoteEntry: {
+                name: BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            ssrPublicPath: publicPath
+        },
+        entry: {
+            file: BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+            path: normalizeRelativePath(node_path.relative(workspaceRoot, node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE))),
+            type: app.remoteType,
+            url: app.containerEntry
+        },
+        exposes: [
+            {
+                id: `${app.backendName}:${BACKEND_FEDERATION_EFFECT_EXPOSE}`,
+                name: BACKEND_FEDERATION_EFFECT_EXPOSE,
+                path: '',
+                assets: {
+                    js: {
+                        async: [],
+                        sync: [
+                            BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+                        ]
+                    },
+                    css: {
+                        async: [],
+                        sync: []
+                    }
+                }
+            }
+        ],
+        shared: [],
+        backendFederation: {
+            role: 'microvertical-server',
+            name: app.backendName,
+            runtimeFramework: 'effect',
+            strictEffectApproach: true,
+            contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+            nodeAdapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+            remoteType: app.remoteType,
+            expose: BACKEND_FEDERATION_EFFECT_EXPOSE,
+            manifestUrl: app.manifestUrl,
+            containerEntry: app.containerEntry,
+            source: {
+                module: sourceModule
+            },
+            readinessPath: `${app.apiPrefix}/${app.apiStem}/readiness`,
+            openapiPath: `${app.apiPrefix}/openapi.json`,
+            ...app.deliveryUnit ? {
+                deliveryUnit: app.deliveryUnit
+            } : {},
+            versionBoundary: {
+                invariant: 'web-and-api-same-build',
+                packageName: app.packageName,
+                version: app.version,
+                buildVersion: app.buildVersion,
+                ...app.uiManifestUrl ? {
+                    uiManifestUrl: app.uiManifestUrl
+                } : {},
+                ...app.deliveryUnit ? {
+                    deliveryUnit: {
+                        unitId: app.deliveryUnit.unitId,
+                        buildMarker: app.deliveryUnit.buildMarker,
+                        sourceRevision: app.deliveryUnit.sourceRevision
+                    }
+                } : {}
+            }
+        }
+    };
+    const validation = validateBackendFederationManifest(manifest, {
+        path: 'backendFederationManifest',
+        requireEffectExpose: true,
+        requireEffectRuntime: true,
+        requireVersionFields: true
+    });
+    if (!validation.ok) throw new Error(`[backend-federation-build] Invalid backend federation manifest: ${formatBackendFederationValidationErrors(validation.errors)}.`);
+    return manifest;
+};
+export { createBackendManifest, createBackendRemoteEntrySource };

package/dist/esm/plugins/backend-federation/config.mjs

@@ -0,0 +1,141 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { promisify } from "node:util";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, deliveryUnitContractBlock, validateDeliveryUnitRecord, validateUltramodernBuildArtifact } from "@modern-js/utils/universal";
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const execFileAsync = promisify(execFile);
+const normalizeRelativePath = (value)=>value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const readJsonFile = async (filePath)=>JSON.parse(await promises.readFile(filePath, 'utf8'));
+const buildArtifactPathFor = (appDirectory)=>node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
+const buildModulePathFor = (appDirectory)=>node_path.join(appDirectory, ULTRAMODERN_BUILD_MODULE_PATH);
+const readBuildIdentity = async (appDirectory)=>{
+    const buildArtifactPath = buildArtifactPathFor(appDirectory);
+    if (existsSync(buildArtifactPath)) {
+        const artifact = await readJsonFile(buildArtifactPath);
+        const artifactValidation = validateUltramodernBuildArtifact(artifact, buildArtifactPath);
+        if (!artifactValidation.ok) throw new Error(`[backend-federation-build] Invalid delivery-unit build artifact at ${buildArtifactPath}.`);
+        const deliveryUnit = artifact.deliveryUnit;
+        return {
+            artifact,
+            appId: deliveryUnit.appId,
+            buildVersion: deliveryUnit.buildMarker,
+            packageName: deliveryUnit.packageName,
+            version: deliveryUnit.version,
+            unitId: deliveryUnit.unitId,
+            sourceRevision: deliveryUnit.sourceRevision
+        };
+    }
+    const buildModulePath = buildModulePathFor(appDirectory);
+    if (!existsSync(buildModulePath)) return {};
+    console.warn(`[backend-federation-build] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ${ULTRAMODERN_BUILD_ARTIFACT_FILE}.`);
+    const source = await promises.readFile(buildModulePath, 'utf8');
+    return {
+        appId: source.match(/\bappId:\s*['"]([^'"]+)['"]/u)?.[1],
+        buildVersion: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+        packageName: source.match(/\bpackageName:\s*['"]([^'"]+)['"]/u)?.[1],
+        version: source.match(/\bversion:\s*['"]([^'"]+)['"]/u)?.[1],
+        unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+        sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
+    };
+};
+const toPascalCase = (value)=>value.split(/[^a-zA-Z0-9]+/u).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
+const stringValue = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+const createBackendName = (app, id)=>{
+    const configuredName = stringValue(app.backendFederation?.name) ?? stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName) ?? stringValue(app.serverExecution?.node?.remoteName);
+    if (configuredName) return configuredName;
+    const mfName = stringValue(app.moduleFederation?.name);
+    return mfName ? `${mfName}Backend` : `vertical${toPascalCase(id)}Backend`;
+};
+const findWorkspaceRoot = (appDirectory)=>{
+    let current = appDirectory;
+    while(true){
+        if (existsSync(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = node_path.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const resolveWorkspaceSourceRevision = async (workspaceRoot)=>{
+    const envRevision = process.env.ULTRAMODERN_SOURCE_REVISION?.trim();
+    if (envRevision) return envRevision;
+    try {
+        const { stdout } = await execFileAsync('git', [
+            '-C',
+            workspaceRoot,
+            'rev-parse',
+            'HEAD'
+        ]);
+        const revision = stdout.trim();
+        if (revision.length > 0) return revision;
+    } catch  {}
+    console.warn('[backend-federation-build] Could not resolve git source revision; stamping sourceRevision as "workspace". Set ULTRAMODERN_SOURCE_REVISION to override.');
+    return 'workspace';
+};
+const createStampedDeliveryUnit = (input)=>{
+    if (!input.unitId || !input.buildMarker || !input.packageName || !input.version) return;
+    const record = {
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: DELIVERY_UNIT_KIND,
+        appId: input.appId,
+        unitId: input.unitId,
+        packageName: input.packageName,
+        version: input.version,
+        buildMarker: input.buildMarker,
+        sourceRevision: input.sourceRevision,
+        deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE
+    };
+    const validation = validateDeliveryUnitRecord(record);
+    if (!validation.ok) return;
+    return deliveryUnitContractBlock(record);
+};
+const createAppFromCompactMetadata = (workspaceRoot, appDirectory, compactApp)=>{
+    const id = stringValue(compactApp.id);
+    const appPath = stringValue(compactApp.path);
+    if (!id || 'vertical' !== compactApp.kind || !isRecord(compactApp.api)) return;
+    const directory = appPath ? normalizeRelativePath(appPath) : `verticals/${id}`;
+    if (node_path.resolve(workspaceRoot, directory) !== node_path.resolve(appDirectory)) return;
+    const port = 'number' == typeof compactApp.port ? compactApp.port : void 0;
+    if (void 0 === port) return;
+    const apiPrefix = stringValue(compactApp.api.prefix) ?? `/${id}-api`;
+    const apiStem = stringValue(compactApp.api.stem) ?? id;
+    const backendName = createBackendName(compactApp, id);
+    const manifestUrl = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.manifestUrl) ?? stringValue(compactApp.serverExecution?.node?.manifestUrl) ?? `http://localhost:${port}/${BACKEND_FEDERATION_MANIFEST_FILE}`;
+    const containerEntry = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.containerEntry) ?? stringValue(compactApp.serverExecution?.node?.containerEntry) ?? `http://localhost:${port}/${BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`;
+    const remoteType = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.remoteType) ?? stringValue(compactApp.serverExecution?.node?.remoteType) ?? 'module';
+    const packageName = stringValue(compactApp.package);
+    const uiManifestUrl = stringValue(compactApp.backendFederation?.versionBoundary?.ui?.manifestUrl) ?? stringValue(compactApp.moduleFederation?.manifestUrl);
+    const compactDeliveryUnit = isRecord(compactApp.deliveryUnit) ? {
+        unitId: stringValue(compactApp.deliveryUnit.unitId),
+        buildMarker: stringValue(compactApp.deliveryUnit.buildMarker),
+        sourceRevision: stringValue(compactApp.deliveryUnit.sourceRevision),
+        packageName: stringValue(compactApp.deliveryUnit.packageName),
+        version: stringValue(compactApp.deliveryUnit.version)
+    } : void 0;
+    return {
+        id,
+        directory,
+        packageName,
+        port,
+        apiPrefix,
+        apiStem,
+        backendName,
+        manifestUrl,
+        containerEntry,
+        remoteType,
+        uiManifestUrl,
+        compactDeliveryUnit
+    };
+};
+const findBackendFederationApp = async (workspaceRoot, appDirectory)=>{
+    const compactConfigPath = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+    const compactConfig = await readJsonFile(compactConfigPath);
+    const apps = Array.isArray(compactConfig.topology?.apps) ? compactConfig.topology.apps : [];
+    for (const app of apps){
+        const resolved = createAppFromCompactMetadata(workspaceRoot, appDirectory, app);
+        if (resolved) return resolved;
+    }
+};
+export { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createAppFromCompactMetadata, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, normalizeRelativePath, readBuildIdentity, resolveWorkspaceSourceRevision };

package/dist/esm/plugins/backend-federation/emit.mjs

@@ -0,0 +1,88 @@
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, stampUltramodernBuildArtifactSourceRevision } from "@modern-js/utils/universal";
+import { createBackendManifest, createBackendRemoteEntrySource } from "./codegen.mjs";
+import { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, readBuildIdentity, resolveWorkspaceSourceRevision } from "./config.mjs";
+const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
+    const workspaceRoot = findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    const effectApiPath = node_path.join(appDirectory, 'api/effect-api.ts');
+    const backendFederationConfigPath = node_path.join(appDirectory, 'backend-federation.config.ts');
+    if (!existsSync(effectApiPath) || !existsSync(backendFederationConfigPath)) return;
+    const app = await findBackendFederationApp(workspaceRoot, appDirectory);
+    if (!app) return;
+    const buildIdentity = await readBuildIdentity(appDirectory);
+    const compactDeliveryUnit = app.compactDeliveryUnit;
+    const hasCompactDeliveryUnit = void 0 !== compactDeliveryUnit && (void 0 !== compactDeliveryUnit.unitId || void 0 !== compactDeliveryUnit.buildMarker || void 0 !== compactDeliveryUnit.packageName || void 0 !== compactDeliveryUnit.version);
+    const hasBuildIdentity = void 0 !== buildIdentity.unitId || void 0 !== buildIdentity.buildVersion || void 0 !== buildIdentity.packageName || void 0 !== buildIdentity.version;
+    if (hasBuildIdentity) {
+        const compactConfigPath = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+        const buildIdentityPath = existsSync(buildArtifactPathFor(appDirectory)) ? buildArtifactPathFor(appDirectory) : buildModulePathFor(appDirectory);
+        const mismatches = [];
+        const compare = (label, a, b, leftLabel = 'deliveryUnit')=>{
+            if (void 0 !== a && void 0 !== b && a !== b) mismatches.push(`${label}: ${leftLabel}=${a} vs ultramodern-build=${b}`);
+        };
+        compare('appId', app.id, buildIdentity.appId, 'topology');
+        if (hasCompactDeliveryUnit) {
+            compare('unitId', compactDeliveryUnit?.unitId, buildIdentity.unitId);
+            compare('buildMarker/build', compactDeliveryUnit?.buildMarker, buildIdentity.buildVersion);
+            compare('packageName', compactDeliveryUnit?.packageName, buildIdentity.packageName);
+            compare('version', compactDeliveryUnit?.version, buildIdentity.version);
+        }
+        if (mismatches.length > 0) throw new Error(`[backend-federation-build] Delivery-unit identity drift between ${compactConfigPath} (topology) and ${buildIdentityPath}: ${mismatches.join('; ')}`);
+    }
+    const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+    const buildVersion = compactDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
+    const sourceRevision = await resolveWorkspaceSourceRevision(workspaceRoot);
+    const packageName = compactDeliveryUnit?.packageName ?? buildIdentity.packageName ?? app.packageName;
+    const version = compactDeliveryUnit?.version ?? buildIdentity.version;
+    const deliveryUnit = createStampedDeliveryUnit({
+        appId: app.id,
+        unitId,
+        buildMarker: buildVersion,
+        packageName,
+        version,
+        sourceRevision
+    });
+    const stampedBuildArtifact = buildIdentity.artifact ? stampUltramodernBuildArtifactSourceRevision(buildIdentity.artifact, sourceRevision) : void 0;
+    const resolvedApp = {
+        ...app,
+        packageName,
+        version,
+        buildVersion,
+        unitId,
+        sourceRevision,
+        deliveryUnit
+    };
+    const manifestPath = node_path.join(distDirectory, BACKEND_FEDERATION_MANIFEST_FILE);
+    const entryPath = node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
+    const deliveryUnitArtifactPath = stampedBuildArtifact ? node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE) : void 0;
+    await promises.mkdir(distDirectory, {
+        recursive: true
+    });
+    await promises.writeFile(entryPath, createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath));
+    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp), null, 2)}\n`);
+    if (stampedBuildArtifact && deliveryUnitArtifactPath) await promises.writeFile(deliveryUnitArtifactPath, `${JSON.stringify(stampedBuildArtifact, null, 2)}\n`);
+    return {
+        appId: resolvedApp.id,
+        manifestPath,
+        containerPath: entryPath,
+        ...deliveryUnitArtifactPath ? {
+            deliveryUnitArtifactPath
+        } : {},
+        remoteName: resolvedApp.backendName,
+        remoteType: resolvedApp.remoteType
+    };
+};
+const emit = ()=>({
+        name: '@modern-js/backend-federation-build',
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const { appDirectory, distDirectory } = api.getAppContext();
+                await emitBackendFederationArtifacts(appDirectory, distDirectory);
+            });
+        }
+    });
+export default emit;
+export { emitBackendFederationArtifacts };