rimecms 0.31.5 → 0.32.0

package/dist/core/constants.js

@@ -0,0 +1,69 @@
+export const PARAMS = {
+    /**
+     * The panel typing over a document: the update lands on the caller's own auto-saved row of the
+     * version `versionId` names, on a config with `versions: { draft: true, autoSave: true }`.
+     * Read by the panel form actions only; the REST API ignores it.
+     *
+     * @example ?/update&autoSave=true&versionId=abc
+     */
+    AUTO_SAVE: 'autoSave',
+    /** Fetch nested documents in relation / link at a specific depth */
+    DEPTH: 'depth',
+    /**
+     * Make a new version. The update starts from the row the other parameters select — the
+     * published one, the newest with `latest`, a named one with `versionId` — copies it into a new
+     * row, a draft unless the body says otherwise, and writes the body onto that row. Without it an
+     * update writes the selected row in place.
+     *
+     * A config with versions and no drafts keeps a version per save: there, an update that names
+     * no `versionId` is a fork whether it says so or not. Every case is tabled on
+     * `defineVersionUpdateOperation` in `core/prototype/shared/versions/strategy.ts`.
+     *
+     * @example PATCH /api/pages/<id>?fork=true
+     */
+    FORK: 'fork',
+    /**
+     * The newest version, whatever its status, where the published one is meant otherwise. The
+     * same on a read and on a write: `GET ?latest=true` returns it, `PATCH ?latest=true` writes
+     * it. `versionId` names a row and makes this moot. Only a config with drafts has a published
+     * row to prefer, and only staff may ask; anyone else gets the published version.
+     *
+     * @example GET /api/pages/<id>?latest=true
+     */
+    LATEST: 'latest',
+    /**
+     * GET operations limit number of documents
+     * @example ?limit=4
+     */
+    LIMIT: 'limit',
+    /** GET / CREATE / UPDATE a specific document locale
+     * @example ?locale=en
+     */
+    LOCALE: 'locale',
+    /** GET documents with an offset number
+     * @example ?limit=4&offset=4
+     */
+    OFFSET: 'offset',
+    /**
+     * Redirect or not after creation operation
+     * @example ?redirect=false
+     */
+    REDIRECT: 'redirect',
+    /** On fetch operation fields to be fetched
+     * @example ?depth=3
+     */
+    SELECT: 'select',
+    /** On fetch list operation order documents
+     * @example ?sort=-title
+     */
+    SORT: 'sort',
+    /** GET / UPDATE a specific version*/
+    VERSION_ID: 'versionId',
+    /** On fetch (upload) list operation filter out documents from a specific uploadPath */
+    UPLOAD_PATH: 'uploadPath',
+    /**
+     * Disable validation on CREATE / UPDATE operations
+     * @example ?skipValidation=true
+     */
+    SKIP_VALIDATION: 'skipValidation'
+};

package/dist/core/constants.server.d.ts

@@ -0,0 +1,5 @@
+export declare const PACKAGE_NAME = "rimecms";
+export declare const IS_RIME_REPO: boolean;
+export declare const RIME_DEV_CACHE_DIR: string;
+/** Consumer branding image convention: drop a file at static/panel/panel.jpg. */
+export declare const PANEL_AUTH_IMAGE = "/assets/panel/panel.jpg";

package/dist/core/constants.server.js

@@ -0,0 +1,6 @@
+import path from 'path';
+export const PACKAGE_NAME = 'rimecms';
+export const IS_RIME_REPO = !import.meta.url.includes('/node_modules/rimecms/');
+export const RIME_DEV_CACHE_DIR = path.resolve(process.cwd(), 'node_modules', '.rime');
+/** Consumer branding image convention: drop a file at static/panel/panel.jpg. */
+export const PANEL_AUTH_IMAGE = '/assets/panel/panel.jpg';

package/dist/core/cors/configure.server.d.ts

@@ -0,0 +1,11 @@
+import type { Config } from '../config/types.js';
+/**
+ * Which origins may call the API, defaulted to the app's own URL.
+ *
+ * A whole-config step, so the feature declares it as `configure`. What it does to the type is
+ * declared in index.ts — `$trustedOrigins` is optional as an author writes it, and the handler
+ * beside this file reads it as a list that is always there.
+ */
+export declare const configureCors: <const T extends Config>(config: T) => T & {
+    readonly $trustedOrigins: string[];
+};

package/dist/core/cors/configure.server.js

@@ -0,0 +1,14 @@
+import { hasProp } from '../../util/object.js';
+/**
+ * Which origins may call the API, defaulted to the app's own URL.
+ *
+ * A whole-config step, so the feature declares it as `configure`. What it does to the type is
+ * declared in index.ts — `$trustedOrigins` is optional as an author writes it, and the handler
+ * beside this file reads it as a list that is always there.
+ */
+export const configureCors = (config) => {
+    const trustedOrigins = hasProp('$trustedOrigins', config) && Array.isArray(config.$trustedOrigins)
+        ? config.$trustedOrigins
+        : [process.env.PUBLIC_RIME_URL];
+    return { ...config, $trustedOrigins: trustedOrigins };
+};

package/dist/core/cors/handler.server.js

@@ -0,0 +1,75 @@
+import { RimeError } from '../errors/index.js';
+import { logger } from '../logger.server.js';
+import { error } from '@sveltejs/kit';
+/**
+ * Validates if the origin is in the trusted origins list
+ */
+function isOriginTrusted(origin, trustedOrigins) {
+    return trustedOrigins.includes(origin);
+}
+/**
+ * Handles preflight OPTIONS requests for CORS
+ */
+function handlePreflightRequest(origin) {
+    return new Response(null, {
+        status: 204,
+        headers: {
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
+            'Access-Control-Allow-Origin': origin,
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-API-Key',
+            'Access-Control-Max-Age': '86400'
+        }
+    });
+}
+/**
+ * Adds CORS headers to the response
+ */
+function addCorsHeaders(response, origin) {
+    response.headers.set('Access-Control-Allow-Origin', origin);
+    response.headers.set('Access-Control-Allow-Credentials', 'true');
+}
+/**
+ * Validates CORS for API routes with Origin header
+ */
+function validateCorsOrigin(origin, trustedOrigins, pathname) {
+    if (!isOriginTrusted(origin, trustedOrigins)) {
+        logger.error(`CORS violation: Origin "${origin}" not in trusted origins for ${pathname}`);
+        throw error(403, RimeError.UNAUTHORIZED || 'CORS origin not allowed');
+    }
+}
+/**
+ * Handles Cross-Origin Resource Sharing (CORS) for API routes
+ *
+ * Only validates CORS when Origin header is present (indicating browser cross-origin request).
+ * Same-origin requests and server-to-server requests don't have Origin header and are allowed.
+ */
+export const handleCORS = async ({ event, resolve }) => {
+    const { rime } = event.locals;
+    // Always a list by here: ./augment.server.ts is this feature's `configure`, and index.ts
+    // declares what it does to the type.
+    const trustedOrigins = rime.config.raw.$trustedOrigins || [];
+    const { isAPI } = event.locals.rime.routes;
+    const IS_OPTIONS_REQUEST = event.request.method === 'OPTIONS';
+    const origin = event.request.headers.get('origin');
+    // Only handle CORS for API routes
+    if (!isAPI) {
+        return resolve(event);
+    }
+    // No Origin header = same-origin or server-to-server request
+    // These don't need CORS validation
+    if (!origin) {
+        return resolve(event);
+    }
+    // Origin header present = browser cross-origin request
+    // Validate the origin is trusted
+    validateCorsOrigin(origin, trustedOrigins, event.url.pathname);
+    // Handle preflight OPTIONS requests
+    if (IS_OPTIONS_REQUEST) {
+        return handlePreflightRequest(origin);
+    }
+    // Process the request
+    const response = await resolve(event);
+    // Add CORS headers for cross-origin requests
+    addCorsHeaders(response, origin);
+    return response;
+};

package/dist/core/cors/module.browser.js

@@ -0,0 +1 @@
+export const configureCors = undefined;

package/dist/core/cors/module.server.d.ts

@@ -0,0 +1 @@
+export { configureCors } from './configure.server.js';

package/dist/core/cors/module.server.js

@@ -0,0 +1,7 @@
+// Server half, and no client half to pair it with — a browser has no origin list to enforce — so
+// a client build resolves the name to `undefined` and the feature simply carries no `configure`
+// there. See `core/dev/codegen/runtime/index.server.ts`.
+//
+// The handler is not here: `handlers/index.ts` imports it directly, because that file is
+// server-only and a feature no longer carries its handler as a property.
+export { configureCors } from './configure.server.js';

package/dist/core/dev/cache.server.d.ts

@@ -0,0 +1,17 @@
+declare function get(key: string): string | false;
+declare function set(key: string, value: string): void;
+/** Whether `content` hashes to what is stored under `key`. Stores nothing. */
+declare function matches(key: string, content: string): boolean;
+/** Records `content` under `key`, as its digest. */
+declare function remember(key: string, content: string): void;
+declare function del(key: string): void;
+declare function clear(): void;
+declare const _default: {
+    get: typeof get;
+    set: typeof set;
+    matches: typeof matches;
+    remember: typeof remember;
+    clear: typeof clear;
+    delete: typeof del;
+};
+export default _default;

package/dist/core/dev/cache.server.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import fs from 'fs';
+import path from 'path';
+import { RIME_DEV_CACHE_DIR } from '../constants.server.js';
+const dev = process.env.NODE_ENV === 'development';
+if (!fs.existsSync(RIME_DEV_CACHE_DIR) && dev) {
+    fs.mkdirSync(RIME_DEV_CACHE_DIR);
+}
+function get(key) {
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
+    const exist = fs.existsSync(keyPath);
+    if (exist) {
+        return fs.readFileSync(keyPath).toString();
+    }
+    return false;
+}
+function set(key, value) {
+    if (!fs.existsSync(RIME_DEV_CACHE_DIR)) {
+        fs.mkdirSync(RIME_DEV_CACHE_DIR);
+    }
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
+    fs.writeFileSync(keyPath, value);
+}
+/**
+ * The two verbs for a memo — content that is only ever compared, never read back.
+ *
+ * Every codegen step asks the same question: is this the string I was given last time? Storing
+ * the answer as a digest keeps a 400KB serialized config out of `node_modules/.rime` and makes
+ * the comparison a fixed 64 bytes:
+ *
+ * ```ts
+ * if (cache.matches('config', memo)) return false;
+ * cache.remember('config', memo);
+ * ```
+ *
+ * Split in two rather than one `changed()` because the schema step stores only once drizzle-kit
+ * has actually generated and migrated — a memo written before the work succeeds would skip it
+ * forever after a failure.
+ */
+const digest = (content) => createHash('sha256').update(content).digest('hex');
+/** Whether `content` hashes to what is stored under `key`. Stores nothing. */
+function matches(key, content) {
+    return get(key) === digest(content);
+}
+/** Records `content` under `key`, as its digest. */
+function remember(key, content) {
+    set(key, digest(content));
+}
+function del(key) {
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
+    if (fs.existsSync(keyPath)) {
+        fs.rmSync(keyPath, { force: true });
+    }
+}
+function clear() {
+    fs.rmSync(RIME_DEV_CACHE_DIR, { recursive: true });
+}
+export default {
+    get,
+    set,
+    matches,
+    remember,
+    clear,
+    delete: del
+};

package/dist/core/dev/cli/commands/build.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { logger } from '../../../logger.server.js';
+import chalk from 'chalk';
+import { spawnSync } from 'child_process';
+import { copyFileSync, cpSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'fs';
+import { getInvokingPackageManager } from '../util/package-manager.server.js';
+import { envProduction, nodeServer } from '../templates/build.js';
+const installCommands = {
+    pnpm: {
+        addDeps: 'pnpm install sharp serve-static',
+        prodInstall: 'pnpm install --prod',
+        runEnv: 'pnpm rime env'
+    },
+    npm: {
+        addDeps: 'npm install sharp serve-static',
+        prodInstall: 'npm install --omit=dev',
+        runEnv: 'npx rime env'
+    }
+};
+export const build = (args) => {
+    // Delete app folder if it exists
+    if (existsSync('./app')) {
+        rmSync('./app', { recursive: true, force: true });
+    }
+    // Build
+    spawnSync('./node_modules/.bin/vite', ['build'], { stdio: 'inherit' });
+    console.log('');
+    // Create app directory
+    mkdirSync('./app', { recursive: true });
+    // Move build folder
+    renameSync('./build', './app/build');
+    logger.info('[✓] /app folder created');
+    // Copy package.json
+    copyFileSync('./package.json', './app/package.json');
+    logger.info('[✓] package.json copied');
+    // Copy db folder if flag is set
+    if (args.withDatabase) {
+        cpSync('./db', './app/db', { recursive: true });
+        logger.info('[✓] database copied');
+    }
+    // Copy static folder if flag is set
+    if (args.withStatic) {
+        cpSync('./static', './app/static', { recursive: true });
+        logger.info('[✓] static directory copied');
+    }
+    // Create main entry server file
+    writeFileSync('./app/index.js', nodeServer);
+    logger.info('[✓] server created at app/index.js');
+    // Create .env file if flag is set
+    const envContent = envProduction();
+    if (args.withEnv) {
+        writeFileSync('./app/.env', envContent);
+        logger.info('[✓] .env file created at app/.env');
+    }
+    console.log('----------------------------------------------------------------\n');
+    console.log('## Next steps :');
+    console.log('');
+    console.log('    cd ./app');
+    const pm = getInvokingPackageManager() === 'pnpm' ? 'pnpm' : 'npm';
+    if (!args.withEnv) {
+        console.log('    ' +
+            installCommands[pm].runEnv +
+            ' ' +
+            chalk.dim(`# next time run \`${pm === 'pnpm' ? 'pnpm' : 'npx'} rime build -e\` to generate the .env file automatically`));
+    }
+    console.log('    ' + installCommands[pm].addDeps);
+    console.log('    ' + installCommands[pm].prodInstall);
+    console.log('');
+    console.log('    node --env-file=.env index.js');
+};

package/dist/core/dev/cli/commands/clear.server.js

@@ -0,0 +1,42 @@
+import { RIME_DEV_CACHE_DIR } from '../../../constants.server.js';
+import { logger } from '../../../logger.server.js';
+import { rmSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_DIR, GENERATED_DIR } from '../../constants.server.js';
+import { prompt } from '../util/prompt.server.js';
+const clearMessage = `Are you sure you want to delete all related rime files (Y/n):
+- ./static/medias
+- ./db
+- ./src/routes/(rime)
+- ./${CONFIG_DIR}
+- ./${GENERATED_DIR}
+- ./src/app.generated.d.ts
+- ./src/rime.generated.d.ts
+- ./src/rime.modules.generated.d.ts
+- ./src/hooks.server.ts
+- ./drizzle.config.ts
+`;
+export const clear = async (args) => {
+    let shouldProceed = true;
+    if (!args.force) {
+        const response = await prompt(`${clearMessage} (Y/n)`, 'n');
+        shouldProceed = response.trim().toLowerCase() === 'y';
+    }
+    if (!shouldProceed) {
+        return logger.info('Operation cancelled. Great!');
+    }
+    // Remove directories
+    rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
+    rmSync(path.join('src', 'routes', '(rime)'), { recursive: true, force: true });
+    rmSync(CONFIG_DIR, { recursive: true, force: true });
+    rmSync(GENERATED_DIR, { recursive: true, force: true });
+    rmSync(path.join('db'), { recursive: true, force: true });
+    rmSync(path.join('static', 'medias'), { recursive: true, force: true });
+    // Remove files
+    rmSync(path.join('src', 'hooks.server.ts'), { force: true });
+    rmSync(path.join('src', 'app.generated.d.ts'), { force: true });
+    rmSync(path.join('src', 'rime.generated.d.ts'), { force: true });
+    rmSync(path.join('src', 'rime.modules.generated.d.ts'), { force: true });
+    rmSync(path.join('drizzle.config.ts'), { force: true });
+    return logger.info('rime cleared');
+};

package/dist/core/dev/cli/commands/generate-exports.server.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Run at prepack, after `svelte-package` — makes this package's `$rime/modules:` splits work for
+ * anyone who installs it.
+ *
+ * In this package's own repo the Vite plugin answers those imports from `src/lib`. An installed
+ * copy has no such plugin, so prepack turns each one into an ordinary package subpath and adds
+ * the `exports` entry that resolves it per environment:
+ *
+ * ```js
+ * // dist/core/prototype/collection/definition.js
+ * import { augmentAuth } from '$rime/modules:core/auth';   // before
+ * import { augmentAuth } from '../../../auth/module';  // after
+ * ```
+ * ```jsonc
+ * "./core/auth/module": {
+ *   "browser": "./dist/core/auth/module.js",
+ *   "default": "./dist/core/auth/module.server.js"
+ * }
+ * ```
+ *
+ * A subpath written into a real `dist` file is followed by esbuild while it pre-bundles the
+ * package, so the half it picks lands *inside* that bundle. The absolute `node_modules` path this
+ * replaces did not — it left half of rime's client graph outside the bundler, CommonJS and all
+ * (see notes/isomorphic-module.md).
+ */
+export declare const generateExports: () => void;

package/dist/core/dev/cli/commands/generate-exports.server.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../../../logger.server.js';
+import { scanModulePairs } from '../../codegen/runtime/index.server.js';
+import { parseExportNames } from '../../codegen/runtime/parse-exports.server.js';
+import { getPackageInfoByKey } from '../util/package.server.js';
+const SPECIFIER = '$rime/modules:';
+/**
+ * Run at prepack, after `svelte-package` — makes this package's `$rime/modules:` splits work for
+ * anyone who installs it.
+ *
+ * In this package's own repo the Vite plugin answers those imports from `src/lib`. An installed
+ * copy has no such plugin, so prepack turns each one into an ordinary package subpath and adds
+ * the `exports` entry that resolves it per environment:
+ *
+ * ```js
+ * // dist/core/prototype/collection/definition.js
+ * import { augmentAuth } from '$rime/modules:core/auth';   // before
+ * import { augmentAuth } from '../../../auth/module';  // after
+ * ```
+ * ```jsonc
+ * "./core/auth/module": {
+ *   "browser": "./dist/core/auth/module.js",
+ *   "default": "./dist/core/auth/module.server.js"
+ * }
+ * ```
+ *
+ * A subpath written into a real `dist` file is followed by esbuild while it pre-bundles the
+ * package, so the half it picks lands *inside* that bundle. The absolute `node_modules` path this
+ * replaces did not — it left half of rime's client graph outside the bundler, CommonJS and all
+ * (see notes/isomorphic-module.md).
+ */
+export const generateExports = () => {
+    const pkgName = getPackageInfoByKey('name');
+    if (!pkgName) {
+        throw new Error("$rime/modules: could not read this package's own name from package.json — the rewrite " +
+            'has no package to qualify its imports with');
+    }
+    const root = process.cwd();
+    const distDir = path.resolve(root, 'dist');
+    if (!fs.existsSync(distDir)) {
+        throw new Error(`$rime/modules: no dist/ at ${distDir} — run this after svelte-package, not before`);
+    }
+    const pairs = scanModulePairs(distDir);
+    const stubs = writeClientStubs(distDir, pairs);
+    rewriteSpecifiers(distDir, pkgName, pairs);
+    writeExports(root, distDir, pairs, stubs);
+    logger.info(`[✓] $rime/modules: ${pairs.size} split(s) exported for ${pkgName}`);
+};
+/** `<subpath>` -> `./dist/...` as `exports` wants it, forward slashes on every platform. */
+const asExportTarget = (distDir, file) => './' + path.relative(path.dirname(distDir), file).split(path.sep).join('/');
+/**
+ * A server-only pair still has to answer on the client, where its names read `undefined` — the
+ * shape a half pair has always had. A condition needs a file to point at, so the stub that used to
+ * be synthesised at request time is written out here.
+ *
+ * ESM binds named exports statically, so an empty module is not enough: `import { x }` throws a
+ * SyntaxError at link time if `x` is absent rather than lazily reading `undefined`.
+ */
+function writeClientStubs(distDir, pairs) {
+    const stubs = new Map();
+    for (const [subpath, entry] of pairs) {
+        if (entry.client || !entry.server)
+            continue;
+        const stubPath = path.join(distDir, subpath, 'module.browser.js');
+        const body = parseExportNames(entry.server)
+            .map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`)
+            .join('\n');
+        fs.writeFileSync(stubPath, `${body}\n`);
+        stubs.set(subpath, stubPath);
+    }
+    return stubs;
+}
+/** Every `$rime/modules:<path>` under dist/ becomes `<pkg>/<subpath>/module`. */
+function rewriteSpecifiers(distDir, pkgName, pairs) {
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (/\.(js|d\.ts)$/.test(entry.name))
+                files.push(full);
+        }
+    };
+    walk(distDir);
+    // Anchored to a statement, not just the string: a doc comment's example line starts with `*`,
+    // and `declare module '$rime/modules:…'` in a generated .d.ts starts with `declare` — neither
+    // is an import, and rewriting either would be wrong.
+    const pattern = /^([ \t]*(?:import|export)\b[^;\n]*?from[ \t]*)(['"])\$rime\/modules:([^'"]*)\2/gm;
+    for (const file of files) {
+        const code = fs.readFileSync(file, 'utf-8');
+        if (!code.includes(SPECIFIER))
+            continue;
+        const rewritten = code.replace(pattern, (_match, head, quote, spec) => {
+            const base = spec.startsWith('.')
+                ? path.resolve(path.dirname(file), spec)
+                : path.resolve(distDir, spec);
+            const subpath = path.relative(distDir, base).split(path.sep).join('/');
+            if (!pairs.has(subpath)) {
+                throw new Error(`$rime/modules:${spec} in ${path.relative(distDir, file)} names no pair — ` +
+                    `nothing at dist/${subpath}/module(.server).js`);
+            }
+            return `${head}${quote}${pkgName}/${subpath}/module${quote}`;
+        });
+        // Anything left in an import position is a shape the pattern above does not handle — a
+        // dynamic `import()`, a bare side-effect import. Better to stop here than to ship a
+        // specifier no consumer can resolve.
+        const missed = rewritten
+            .split('\n')
+            .find((line) => /^[ \t]*(?:import|export)\b/.test(line) && line.includes(SPECIFIER));
+        if (missed) {
+            throw new Error(`${path.relative(distDir, file)}: \`${missed.trim()}\` was not rewritten — ` +
+                'only static `from` imports are supported');
+        }
+        fs.writeFileSync(file, rewritten);
+    }
+}
+/**
+ * One `exports` entry per pair, plus the two fixes every pre-existing entry needs.
+ *
+ * `browser` has to come before `svelte`: vite-plugin-svelte applies `svelte` to both environments,
+ * conditions are first-match-wins, and an entry led by `svelte` therefore hands the client build
+ * the server half. And an entry with no `default` fails to resolve through the map at all.
+ */
+function writeExports(root, distDir, pairs, stubs) {
+    const pkgPath = path.join(root, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const exportsMap = pkg.exports ?? {};
+    // Idempotent: this command runs on every prepack, and a pair that disappeared must not leave
+    // its entry behind pointing at a file dist/ no longer has.
+    for (const key of Object.keys(exportsMap)) {
+        if (key.endsWith('/module'))
+            delete exportsMap[key];
+    }
+    for (const [subpath, entry] of pairs) {
+        const client = entry.client || stubs.get(subpath);
+        const server = entry.server;
+        const types = (server || entry.client).replace(/\.js$/, '.d.ts');
+        exportsMap[`./${subpath}/module`] = {
+            ...(fs.existsSync(types) ? { types: asExportTarget(distDir, types) } : {}),
+            ...(client ? { browser: asExportTarget(distDir, client) } : {}),
+            default: asExportTarget(distDir, (server || entry.client))
+        };
+    }
+    for (const [key, value] of Object.entries(exportsMap)) {
+        if (key.endsWith('/module') || typeof value !== 'object' || value === null)
+            continue;
+        const conditions = value;
+        if (!conditions.default && conditions.import)
+            conditions.default = conditions.import;
+    }
+    pkg.exports = exportsMap;
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}