dshmarket 1.65.2 → 1.65.3

package/lib/hot.js

@@ -30,8 +30,6 @@ import { pathToFileURL } from 'node:url';
 import { asChannel } from './channels.js';
 import { asRegion, normalizeGithubProxy } from './regions.js';
 import { logEvent } from './log.js';
-import { writeFileAtomic } from './atomic-write.js';
-import { waitForLifecycle } from './lifecycle.js';
 import { declaredBundlePatchFile, entryArtifactExists } from './profile.js';
 /**
  * Profile-scoped resolution for hot-mount rows: turn a bare package name into
@@ -379,10 +377,7 @@ export function writeMarketState(profileDir, state) {
     const broken = Object.prototype.hasOwnProperty.call(state, 'brokenPlugins')
         ? state.brokenPlugins
         : onDisk.brokenPlugins;
-    // Written atomically: a crash or a refused rename mid-write must not
-    // leave a truncated state.json behind, because the next boot reads it as
-    // the user‘s disable list and the toggle that produced it is gone (#582).
-    const text = JSON.stringify({
+    writeFileSync(stateFile(profileDir), JSON.stringify({
         disabled: [...state.disabled],
         groups: state.groups,
         groupOrder: state.groupOrder,
@@ -406,8 +401,7 @@ export function writeMarketState(profileDir, state) {
         // Omitted while not saved, so a card that was never touched keeps
         // inheriting the composition's buildEnv on every boot.
         ...(state.buildEnv === undefined ? {} : { buildEnv: state.buildEnv }),
-    });
-    writeFileAtomic(stateFile(profileDir), text);
+    }));
 }
 /** Plugins the user switched off; skipped by the boot re-mount. */
 export function readDisabled(profileDir) {
@@ -455,54 +449,19 @@ function raceActivationTimeout(awaitable) {
  * @param packageName - package to unmount.
  * @returns true when a live hot mount was found and disposed.
  */
-const hotDisposalErrors = new Map();
-/**
- * Why the last disposal of this package failed, if it did.
- *
- * A rejected disposal leaves runtime state nobody can describe, so the toggle
- * must refuse to enable that package again until a disposal has been seen
- * through. The message is kept addressable for exactly that refusal.
- */
-export function hotMountDisposalError(packageName) {
-    return hotDisposalErrors.get(packageName);
-}
-/**
- * Remove a live market hot mount.
- *
- * @param strict - a toggle caller: retain the handle when disposal fails (so
- * the failure stays addressable for a retry) and propagate the error instead
- * of reporting a removal that did not happen. Legacy callers keep best-effort
- * removal, which is what the boot replay and the recovery paths expect.
- */
-export async function hotUnmount(packageName, strict = false) {
+export async function hotUnmount(packageName) {
     const handle = hotHandles.get(packageName);
     if (handle === undefined)
         return false;
-    if (!strict) {
-        hotHandles.delete(packageName);
-        shimNames.delete(packageName);
-        hotDisposalErrors.delete(packageName);
-    }
+    hotHandles.delete(packageName);
+    shimNames.delete(packageName);
     try {
-        if (strict)
-            await waitForLifecycle(handle, () => handle.dispose(), `${packageName}: dispose`);
-        else
-            await handle.dispose();
-        if (!strict || hotHandles.get(packageName) === handle) {
-            hotHandles.delete(packageName);
-            shimNames.delete(packageName);
-            hotDisposalErrors.delete(packageName);
-        }
+        await handle.dispose();
         logEvent('info', 'hot-unmount', `${packageName}: removed live`);
         return true;
     }
     catch (error) {
-        const reason = `${packageName}: dispose failed — ${error instanceof Error ? error.message : String(error)}`;
-        if (strict) {
-            hotDisposalErrors.set(packageName, reason);
-            throw new Error(reason);
-        }
-        logEvent('warn', 'hot-unmount', reason);
+        logEvent('warn', 'hot-unmount', `${packageName}: dispose failed — ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }
 }
@@ -522,7 +481,6 @@ export async function hotMount(ctx, profileDir, packageName) {
         if (HotTree === null) {
             return {
                 ok: false,
-                outcome: 'deferred',
                 reason: '宿主不支持热挂载(include 插件不可导入),需重启 / the host cannot hot-mount (include plugin unavailable); restart required',
             };
         }
@@ -550,7 +508,6 @@ export async function hotMount(ctx, profileDir, packageName) {
             if (rows === null) {
                 return {
                     ok: false,
-                    outcome: 'deferred',
                     reason: 'bundle patch 含配置行/表达式,热挂载仅支持纯 insert,重启后生效 / the bundle patch contains config/expression rows; hot-mount only supports plain inserts — it activates on restart',
                 };
             }
@@ -564,7 +521,6 @@ export async function hotMount(ctx, profileDir, packageName) {
             if (dsh === null || dsh.client === undefined || dsh.bundle !== undefined) {
                 return {
                     ok: false,
-                    outcome: 'failed',
                     reason: '该包无 bundle patch 且未声明 dsh.client,没有可热挂载的内容 / no bundle patch and no dsh.client surface — nothing to hot-mount',
                 };
             }
@@ -613,27 +569,15 @@ export async function hotMount(ctx, profileDir, packageName) {
             throw error;
         }
         hotHandles.set(packageName, handle);
-        hotDisposalErrors.delete(packageName);
         ctx.logger?.info?.(`[dsh-market] hot-mounted ${packageName}`);
         logEvent('info', 'hot-mount', `${packageName}: live${shimNames.has(packageName) ? ' (client-only shim)' : ''}`);
-        return { ok: true, outcome: 'live', reason: null };
+        return { ok: true, reason: null };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        // The distinction the toggle needs: a timeout is the host failing to
-        // settle, a rejection is the plugin failing. The first keeps the restart
-        // contract the market has always shown; the second is evidence a durable
-        // enable must not be published from.
-        const deferred = error instanceof ActivationTimeout;
-        ctx.logger?.warn(`[dsh-market] hot mount of ${packageName} failed: ${message}`);
-        logEvent('warn', 'hot-mount', `${packageName}: ${deferred ? 'fell back to restart' : 'activation failed'} — ${message}`);
-        return {
-            ok: false,
-            outcome: deferred ? 'deferred' : 'failed',
-            reason: deferred
-                ? `热挂载超时,需重启 — ${message} / hot-mount timed out — restart required: ${message}`
-                : `热挂载失败 — ${message} / hot-mount failed: ${message}`,
-        };
+        ctx.logger?.warn(`[dsh-market] hot mount of ${packageName} failed, restart required: ${message}`);
+        logEvent('warn', 'hot-mount', `${packageName}: fell back to restart — ${message}`);
+        return { ok: false, reason: `热挂载失败,重启后生效 — ${message} / hot-mount failed — restart required: ${message}` };
     }
 }
 /**

package/lib/patch.js

@@ -489,7 +489,7 @@ function appendPatchEntry(patchPath, block) {
     return { ok: true, reason: null };
 }
 /** Disable one row: append `- id: X` + `disabled: true` (idempotent). */
-export function disableRow(patchPath, rowId, logChange = true) {
+export function disableRow(patchPath, rowId) {
     return queuedWrite(async () => {
         if (!ROW_ID_RE.test(rowId)) {
             return { ok: false, reason: `行 id 含特殊字符,不支持写入补丁层 / row id ${rowId} cannot be written to the patch layer` };
@@ -498,20 +498,14 @@ export function disableRow(patchPath, rowId, logChange = true) {
         if (state.disables.includes(rowId))
             return { ok: true, reason: null };
         const result = appendPatchEntry(patchPath, rowBlock(rowId, true));
-        if (result.ok && logChange)
+        if (result.ok)
             logEvent('info', 'patch', `disabled row ${rowId} in ${patchPath}`);
         return result;
     });
 }
-/**
- * Enable one row: remove the `disabled: true` block; force-enable with
- * `disabled: false` when a lower layer (bundle/home patch) holds it down.
- *
- * `logChange` is false for a scratch write — the toggle stages and validates
- * its rows on a copy first (#582), and a log line claiming a row was written
- * before anything was published is worse than no line at all.
- */
-export function enableRow(patchPath, rowId, logChange = true) {
+/** Enable one row: remove the `disabled: true` block; force-enable with
+ * `disabled: false` when a lower layer (bundle/home patch) holds it down. */
+export function enableRow(patchPath, rowId) {
     return queuedWrite(async () => {
         if (!ROW_ID_RE.test(rowId)) {
             return { ok: false, reason: `行 id 含特殊字符,不支持写入补丁层 / row id ${rowId} cannot be written to the patch layer` };
@@ -528,14 +522,13 @@ export function enableRow(patchPath, rowId, logChange = true) {
         })();
         if (blockRe.test(text)) {
             writeFileSync(patchPath, withPlaceholderRestored(text.replace(blockRe, '')));
-            if (logChange)
-                logEvent('info', 'patch', `enabled row ${rowId} in ${patchPath}`);
+            logEvent('info', 'patch', `enabled row ${rowId} in ${patchPath}`);
             return { ok: true, reason: null };
         }
         if (state.forced.includes(rowId))
             return { ok: true, reason: null };
         const result = appendPatchEntry(patchPath, rowBlock(rowId, false));
-        if (result.ok && logChange)
+        if (result.ok)
             logEvent('info', 'patch', `force-enabled row ${rowId} in ${patchPath}`);
         return result;
     });