@cosmicdrift/kumiko-framework 0.363.0 → 0.365.0

package/dist/pipeline/notify-scope.js

@@ -23,8 +23,10 @@ export function createDeferringNotify(deps) {
             assertNotificationVariables(registry, notificationType, options.data);
         if (options.immediate === true)
             return notifyNow(notificationType, options);
+        // The hook runs after the handler returned; a caller reusing `data` meanwhile must not change what is sent.
+        const optionsAtCallTime = structuredClone(options);
         scheduleAfterCommit(async () => {
-            await notifyAfterCommit(notificationType, options);
+            await notifyAfterCommit(notificationType, optionsAtCallTime);
         });
         return { kind: "deferred" };
     }

package/dist/pipeline/pre-transaction-reservations.d.ts

@@ -1,12 +1,14 @@
 import type { ReservationHandle } from "@cosmicdrift/kumiko-types/handlers";
-import type { SessionUser } from "../engine/types/index.js";
+import type { SessionUser, WriteHandlerDef } from "../engine/types/index.js";
 import { type WriteErrorInfo } from "../errors/index.js";
 import type { BatchCommand, DispatchContext } from "./dispatch-shared.js";
 import type { WriteOrigin } from "./write-origin.js";
 type ReservationConfirm = ReservationHandle["confirmInTransaction"];
 export type ConsumedReservation = {
     readonly confirmInTransaction: ReservationConfirm | undefined;
+    readonly prepared: unknown;
 };
+export declare function hasPreTransactionPhase(handler: WriteHandlerDef): boolean;
 export declare function runAsCommand<T>(reserved: {
     readonly type: string;
     readonly reservation: ConsumedReservation;

package/dist/pipeline/pre-transaction-reservations.js

@@ -1,10 +1,13 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { toWriteErrorInfo } from "../errors/index.js";
 import { createFallbackLogger } from "../logging/utils.js";
-import { buildHandlerContext, isMemberResolutionPrincipal } from "./dispatch-shared.js";
+import { applyBeforeTransactionReadOnly, buildHandlerContext, denyTransactionBoundSurfaces, isMemberResolutionPrincipal, } from "./dispatch-shared.js";
 import { wrapToKumiko } from "./dispatcher-utils.js";
 import { runPreHandlerGates } from "./pre-handler-gates.js";
 import { effectiveWriteOrigin, rootWriteOrigin } from "./write-origin.js";
+export function hasPreTransactionPhase(handler) {
+    return handler.reserveBeforeTransaction !== undefined || handler.beforeTransaction !== undefined;
+}
 // One-shot permission per top-level command: the handler that reserved before the transaction
 // consumes it on entry. A capped handler reached any other way (nested ctx.write, writeAs, a
 // second execution of the same type) finds it spent and is rejected instead of running unreserved.
@@ -36,13 +39,13 @@ async function releaseAll(ctx, releases) {
             await release();
         }
         catch (error) {
-            log.error("releasing a pre-transaction reservation failed", { error });
+            log.error("releasing a pre-transaction phase failed", { error });
         }
     }
 }
 // Same gates as the in-transaction run, but before any transaction: a caller who is rate limited,
-// denied or sends an invalid payload never reserves anything, so a rejected request cannot consume
-// capacity or trigger the reservation's side effects.
+// denied or sends an invalid payload never reserves or prepares anything, so a rejected request
+// cannot consume capacity or trigger external calls.
 export async function reserveBeforeTransaction(ctx, commands, user, inheritedOrigin) {
     const releases = [];
     const reservedCommands = new Map();
@@ -51,7 +54,7 @@ export async function reserveBeforeTransaction(ctx, commands, user, inheritedOri
     for (const [index, command] of commands.entries()) {
         try {
             const handler = ctx.registry.getWriteHandler(command.type);
-            if (!handler?.reserveBeforeTransaction)
+            if (!handler || !hasPreTransactionPhase(handler))
                 continue;
             const gates = await runPreHandlerGates(ctx, handler, command.type, command.payload, user, "charge");
             if (!gates.isSuccess) {
@@ -60,10 +63,27 @@ export async function reserveBeforeTransaction(ctx, commands, user, inheritedOri
             }
             const origin = effectiveWriteOrigin(rootWriteOrigin(ctx.registry, command.type, user), inheritedOrigin);
             const handlerContext = await buildHandlerContext(ctx, command.type, user, origin);
-            const handle = toReservationHandle(await handler.reserveBeforeTransaction({ type: command.type, payload: gates.payload, user }, handlerContext));
-            if (handle)
-                releases.push(handle.release);
-            reservedCommands.set(index, { confirmInTransaction: handle?.confirmInTransaction });
+            const event = { type: command.type, payload: gates.payload, user };
+            let confirmInTransaction;
+            if (handler.reserveBeforeTransaction) {
+                const handle = toReservationHandle(await handler.reserveBeforeTransaction(event, denyTransactionBoundSurfaces(handlerContext)));
+                if (handle)
+                    releases.push(handle.release);
+                confirmInTransaction = handle?.confirmInTransaction;
+            }
+            let prepared;
+            if (handler.beforeTransaction) {
+                const phaseContext = await buildHandlerContext(ctx, command.type, user, origin, undefined, undefined, undefined, undefined, undefined, true);
+                const phase = await handler.beforeTransaction(event, applyBeforeTransactionReadOnly(phaseContext));
+                if (!phase.isSuccess) {
+                    await releaseAll(ctx, releases);
+                    return { isSuccess: false, error: phase.error, failedIndex: index };
+                }
+                if (phase.release)
+                    releases.push(phase.release);
+                prepared = phase.data;
+            }
+            reservedCommands.set(index, { confirmInTransaction, prepared });
         }
         catch (error) {
             await releaseAll(ctx, releases);

package/dist/rate-limit/bucket.d.ts

@@ -1,4 +1,4 @@
-import type { RateLimitOption, SessionUser } from "../engine/types/index.js";
+import type { PayloadBucketNormalization, RateLimitOption, SessionUser } from "../engine/types/index.js";
 export type BucketContext = {
     readonly handlerName: string;
     readonly user: SessionUser;
@@ -12,7 +12,7 @@ export type BucketResult = {
     readonly reason: string;
 };
 export declare function buildBucketKey(option: RateLimitOption, ctx: BucketContext): BucketResult;
-export declare function normalizePayloadBucketValue(value: string): string;
-export declare function buildPayloadBucketKey(handlerName: string, field: string, digest: string): string;
+export declare function normalizePayloadBucketValue(value: string, normalize?: PayloadBucketNormalization): string;
+export declare function buildPayloadBucketKey(tenantId: string, handlerName: string, field: string, digest: string): string;
 export declare function toPublicBucketName(bucket: string): string;
 export declare function createPayloadDigest(masterSecret: string): (value: string) => string;

package/dist/rate-limit/bucket.js

@@ -23,11 +23,21 @@ export function buildBucketKey(option, ctx) {
 // Payload-field buckets: the value (e.g. a recipient address) is normalized
 // and HMAC-hashed so Redis never holds it in plaintext.
 const PAYLOAD_BUCKET_PURPOSE = "kumiko:rate-limit:payload-bucket";
-export function normalizePayloadBucketValue(value) {
-    return value.trim().toLowerCase();
+export function normalizePayloadBucketValue(value, normalize) {
+    const base = value.normalize("NFKC").trim().toLowerCase();
+    return normalize === "email" ? stripEmailPlusTag(base) : base;
 }
-export function buildPayloadBucketKey(handlerName, field, digest) {
-    return `payload+handler:${handlerName}:${field}:${digest}`;
+// Only the `+tag` suffix is dropped; provider-specific dot rules are not applied.
+function stripEmailPlusTag(address) {
+    const at = address.lastIndexOf("@");
+    if (at === -1)
+        return address;
+    const local = address.slice(0, at);
+    const plus = local.indexOf("+");
+    return plus <= 0 ? address : `${local.slice(0, plus)}${address.slice(at)}`;
+}
+export function buildPayloadBucketKey(tenantId, handlerName, field, digest) {
+    return `payload+handler:${tenantId}:${handlerName}:${field}:${digest}`;
 }
 // Everything after the scope tag identifies the caller (IP, user/tenant id,
 // auth target, payload digest). IPv6 addresses and handler names contain ":",

package/dist/redis/cache-sync-bus.js

@@ -64,7 +64,12 @@ function createLocalFanout() {
 export function createLocalCacheSyncBus() {
     const fanout = createLocalFanout();
     return {
-        publish: fanout.deliver,
+        publish(topic, message, options) {
+            // skip: a single-process bus has no remote subscribers to reach
+            if (options?.remoteOnly)
+                return;
+            fanout.deliver(topic, message);
+        },
         subscribe: fanout.subscribe,
         onResync: fanout.onResync,
         async close() { },
@@ -108,8 +113,9 @@ export function createCacheSyncBusOverSignal(signal, opts) {
         }
     });
     return {
-        publish(topic, message) {
-            fanout.deliver(topic, message);
+        publish(topic, message, options) {
+            if (!options?.remoteOnly)
+                fanout.deliver(topic, message);
             const envelope = { origin, topic, message };
             signal.publish(opts.channel, envelope);
         },

package/dist/schema-cli.js

@@ -439,8 +439,19 @@ export async function runSchemaCli(argv, appCwd, out, options = {}) {
                 await reportLeftoverDroppedTables(db, migrationsDir, out);
                 return pending === 0 ? 0 : 1;
             }
+            catch (e) {
+                // Message only, never dbUrl: it can carry the password.
+                out.err(`  ✗ schema status failed: ${e instanceof Error ? e.message : String(e)}`);
+                out.err('  Check that DATABASE_URL is reachable and the database exists (the scaffold\'s docker-compose creates "app").');
+                return 1;
+            }
             finally {
-                await close();
+                try {
+                    await close();
+                }
+                catch {
+                    // The connection already failed and was reported above; a failing close must not throw again.
+                }
             }
         }
         default: {

package/dist/search/meilisearch-adapter.js

@@ -23,6 +23,27 @@ const REMOVE_TOLERATED_ERROR_CODES = [ErrorStatusCode.INDEX_NOT_FOUND];
 const INDEX_LIST_PAGE_SIZE = 100;
 // What an unconfigured Meilisearch index reports as searchableAttributes.
 const MEILI_ALL_ATTRIBUTES = "*";
+const DEFAULT_FILTERABLE_ATTRIBUTES = ["_type", "_weight"];
+const DEFAULT_SORTABLE_ATTRIBUTES = ["_weight"];
+function defaultSearchableAttributes(config) {
+    return config.rankingFields ?? config.searchableFields;
+}
+// Meilisearch may return granular filterable objects; those are never part of our default.
+function isSubsetOf(stored, wanted) {
+    return stored.every((attribute) => typeof attribute === "string" && wanted.includes(attribute));
+}
+// A stored list that lies inside the current default and misses attributes is an
+// older default that gained fields since; anything with a foreign attribute is
+// an explicit configure() and stays untouched.
+function isOutdatedDefault(stored, wanted) {
+    const pairs = [
+        [stored.searchable, wanted.searchable],
+        [stored.filterable, wanted.filterable],
+        [stored.sortable, wanted.sortable],
+    ];
+    return (pairs.every(([have, want]) => isSubsetOf(have, want)) &&
+        pairs.some(([have, want]) => want.some((attribute) => !have.includes(attribute))));
+}
 function isIndexNotFound(err) {
     const cause = typeof err === "object" && err !== null && "cause" in err ? err.cause : null;
     return errorCodeOf(cause) === ErrorStatusCode.INDEX_NOT_FOUND;
@@ -54,10 +75,9 @@ export function createMeilisearchAdapter(options) {
     }
     async function applyConfig(tenantId, config) {
         const index = client.index(meilisearchTenantIndex(prefix, tenantId));
-        const fields = config.rankingFields ?? config.searchableFields;
-        await awaitSucceededTask(index.updateSearchableAttributes([...fields]));
-        await awaitSucceededTask(index.updateFilterableAttributes(["_type", "_weight"]));
-        await awaitSucceededTask(index.updateSortableAttributes(["_weight"]));
+        await awaitSucceededTask(index.updateSearchableAttributes([...defaultSearchableAttributes(config)]));
+        await awaitSucceededTask(index.updateFilterableAttributes([...DEFAULT_FILTERABLE_ATTRIBUTES]));
+        await awaitSucceededTask(index.updateSortableAttributes([...DEFAULT_SORTABLE_ATTRIBUTES]));
     }
     // Lazily configures a tenant's index off the default config on its first
     // access, so callers that never call `configure` still get a filterable/
@@ -67,15 +87,22 @@ export function createMeilisearchAdapter(options) {
     // Meili outage doesn't permanently poison the tenant for the process.
     // The configured-tenants map is process memory only: after a restart a stored explicit
     // configure() must not be overwritten by the registry default, so the default is applied only
-    // to an index that is missing or still carries Meilisearch's factory settings.
-    async function indexNeedsDefaultConfig(tenantId) {
+    // to an index that is missing, carries Meilisearch's factory settings, or holds an older
+    // default that is a strict subset of the current one (fields were added by a deploy).
+    async function indexNeedsDefaultConfig(tenantId, config) {
         try {
             const settings = await client.index(meilisearchTenantIndex(prefix, tenantId)).getSettings();
             const searchable = settings.searchableAttributes ?? [MEILI_ALL_ATTRIBUTES];
             const filterable = settings.filterableAttributes ?? [];
-            return (searchable.length === 1 &&
+            const factorySettings = searchable.length === 1 &&
                 searchable[0] === MEILI_ALL_ATTRIBUTES &&
-                !filterable.includes("_type"));
+                !filterable.includes("_type");
+            return (factorySettings ||
+                isOutdatedDefault({ searchable, filterable, sortable: settings.sortableAttributes ?? [] }, {
+                    searchable: defaultSearchableAttributes(config),
+                    filterable: DEFAULT_FILTERABLE_ATTRIBUTES,
+                    sortable: DEFAULT_SORTABLE_ATTRIBUTES,
+                }));
         }
         catch (err) {
             if (isIndexNotFound(err))
@@ -95,7 +122,7 @@ export function createMeilisearchAdapter(options) {
         }
         const config = defaultConfig;
         await trackConfigure(tenantId, async () => {
-            if (await indexNeedsDefaultConfig(tenantId))
+            if (await indexNeedsDefaultConfig(tenantId, config))
                 await applyConfig(tenantId, config);
         });
     }

package/dist/stack/db.d.ts

@@ -1,9 +1,9 @@
-import type { DbConnection } from "@cosmicdrift/kumiko-types/db-connection";
+import type { DbConnection, PgListenClient } from "@cosmicdrift/kumiko-types/db-connection";
 declare function requireEnv(name: string): string;
 export type TestDb = {
     db: DbConnection;
     outsideTransactionDb: DbConnection;
-    client: unknown;
+    client: PgListenClient;
     dbName: string;
     cleanup: () => Promise<void>;
 };

package/dist/stack/test-stack.js

@@ -275,7 +275,8 @@ export async function setupTestStack(options) {
             (appContext.redis === undefined || options.rateLimitNowMs !== undefined);
         const rateLimitFallback = needsOwnRateLimitResolver
             ? createRateLimitResolver({
-                redis: testRedis.redis,
+                // An app-supplied redis keeps buckets and app redis on the same instance.
+                redis: appContext.redis ?? testRedis.redis,
                 ...(options.rateLimitNowMs ? { nowMs: options.rateLimitNowMs } : {}),
             })
             : undefined;

package/dist/testing/index.d.ts

@@ -22,3 +22,4 @@ export { sharedItemEntity, sharedItemTable, sharedUserEntity, sharedUserTable, s
 export { sleep } from "./utils.js";
 export { waitFor } from "./wait-for.js";
 export { withoutAmbientTemporal } from "./without-ambient-temporal.js";
+export { zipWithEntries } from "./zip-fixture.js";

package/dist/testing/index.js

@@ -30,3 +30,4 @@ export { sharedItemEntity, sharedItemTable, sharedUserEntity, sharedUserTable, s
 export { sleep } from "./utils.js";
 export { waitFor } from "./wait-for.js";
 export { withoutAmbientTemporal } from "./without-ambient-temporal.js";
+export { zipWithEntries } from "./zip-fixture.js";

package/dist/testing/multipart-helper.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Serializes a FormData instance to multipart/form-data bytes.
+ *
+ * Returns the encoded body and the Content-Type header value (including the
+ * generated boundary). Pass both directly to app.request or fetch.
+ */
 export declare function buildMultipartBody(fd: FormData): Promise<{
     body: BodyInit;
     contentType: string;

package/dist/testing/multipart-helper.js

@@ -1,3 +1,4 @@
+import { isPlainObject } from "@cosmicdrift/kumiko-types/type-guards";
 // Workarounds for Bun v1.3.x bun:test limitations with multipart/form-data.
 //
 // Two bugs combine to break file upload tests in bun:test:
@@ -19,7 +20,6 @@
  * Returns the encoded body and the Content-Type header value (including the
  * generated boundary). Pass both directly to app.request or fetch.
  */
-import { isPlainObject } from "@cosmicdrift/kumiko-types/type-guards";
 export async function buildMultipartBody(fd) {
     const boundary = `KumikoBnd${Date.now()}${Math.random().toString(36).slice(2, 8)}`;
     const enc = new TextEncoder();

package/dist/testing/zip-fixture.d.ts

@@ -0,0 +1 @@
+export declare function zipWithEntries(...entryNames: readonly string[]): Uint8Array;

package/dist/testing/zip-fixture.js

@@ -0,0 +1,33 @@
+const LOCAL_HEADER_FIXED_LENGTH = 30;
+const CENTRAL_HEADER_FIXED_LENGTH = 46;
+const EOCD_LENGTH = 22;
+// Minimal stored ZIP (no compression, zero CRC): enough structure for readers that
+// walk the central directory. Not for extraction.
+export function zipWithEntries(...entryNames) {
+    const encoder = new TextEncoder();
+    const names = entryNames.map((name) => encoder.encode(name));
+    const localSize = names.reduce((sum, name) => sum + LOCAL_HEADER_FIXED_LENGTH + name.length, 0);
+    const centralSize = names.reduce((sum, name) => sum + CENTRAL_HEADER_FIXED_LENGTH + name.length, 0);
+    const bytes = new Uint8Array(localSize + centralSize + EOCD_LENGTH);
+    const view = new DataView(bytes.buffer);
+    let localOffset = 0;
+    let centralOffset = localSize;
+    for (const name of names) {
+        view.setUint32(localOffset, 0x04034b50, true);
+        view.setUint16(localOffset + 26, name.length, true);
+        bytes.set(name, localOffset + LOCAL_HEADER_FIXED_LENGTH);
+        view.setUint32(centralOffset, 0x02014b50, true);
+        view.setUint16(centralOffset + 28, name.length, true);
+        view.setUint32(centralOffset + 42, localOffset, true);
+        bytes.set(name, centralOffset + CENTRAL_HEADER_FIXED_LENGTH);
+        localOffset += LOCAL_HEADER_FIXED_LENGTH + name.length;
+        centralOffset += CENTRAL_HEADER_FIXED_LENGTH + name.length;
+    }
+    const eocdOffset = localSize + centralSize;
+    view.setUint32(eocdOffset, 0x06054b50, true);
+    view.setUint16(eocdOffset + 8, names.length, true);
+    view.setUint16(eocdOffset + 10, names.length, true);
+    view.setUint32(eocdOffset + 12, centralSize, true);
+    view.setUint32(eocdOffset + 16, localSize, true);
+    return bytes;
+}

package/dist/ui-types/card-column-roles.js

@@ -18,8 +18,10 @@ export function cardFileDisplayKind(type, renderer) {
 // boot validator so the validator counts exactly what the card would draw.
 // The first image column is the card's leading preview, neither title nor meta.
 export function cardColumnRoles(columns) {
-    const image = columns.find((col) => col.fileDisplay?.kind === "image");
-    const textColumns = columns.filter((col) => col !== image);
+    const isImage = (col) => col.fileDisplay?.kind === "image";
+    const image = columns.find((col) => isImage(col) && col.hideOnNarrow !== true);
+    // A narrow-hidden image must not turn into the title just because it is not the preview.
+    const textColumns = columns.filter((col) => col !== image && !(isImage(col) && col.hideOnNarrow === true));
     const title = textColumns.find((col) => col.highlighted === true) ?? textColumns[0];
     const status = textColumns.find((col) => col !== title && col.type === "select" && col.renderer === undefined);
     const meta = textColumns.filter((col) => col !== title && col !== status && col.hideOnNarrow !== true);

package/dist/ui-types/index.d.ts

@@ -4,7 +4,7 @@ export { computeDerivedCellValue, roundDerivedCellValue } from "../engine/embedd
 export type { ParsedRefTarget } from "../engine/parse-ref-target.js";
 export { parseRefTarget } from "../engine/parse-ref-target.js";
 export type { FieldsOrGroupsSection, UnavailableSelectOption } from "../engine/screen-helpers.js";
-export { availableSelectOptions, evalFieldCondition, explicitListScreenId, findUnavailableSelectOptions, isExtensionEditSection, isFieldsEditSection, isFormatSpec, isRecordLocked, isWriteFormEditSection, normalizeEditField, normalizeListColumn, resolveNavParentScreen, sectionFieldSpecs, } from "../engine/screen-helpers.js";
+export { availableSelectOptions, evalFieldCondition, explicitListScreenId, findUnavailableSelectOptions, isExtensionEditSection, isFieldsEditSection, isFormatSpec, isRecordLocked, isUnchangedValue, isWriteFormEditSection, normalizeEditField, normalizeListColumn, resolveNavParentScreen, sectionFieldSpecs, } from "../engine/screen-helpers.js";
 export type { BooleanFieldDef, DateFieldDef, EmbeddedDerivedCellDef, EntityDefinition, FieldDefinition, FileFieldDef, FilesFieldDef, ImageFieldDef, ImagesFieldDef, NumberFieldDef, OptionsQueryPayload, OptionsQueryPayloadValue, SelectFieldDef, SelectOptionTone, TextFieldDef, } from "../engine/types/fields.js";
 export type { AccessRule, OpenToAllAccessRule, OpenToAllDeclaration, OpenToAllPersonalData, RoleAccessPersonalData, RoleAccessRule, } from "../engine/types/handlers.js";
 export { isOpenToAllGranted, isUiAccessGranted } from "../engine/types/handlers.js";

package/dist/ui-types/index.js

@@ -22,7 +22,7 @@
 export { NO_WIDGET_FIELD_TYPES } from "@cosmicdrift/kumiko-types/fields";
 export { computeDerivedCellValue, roundDerivedCellValue } from "../engine/embedded-derived.js";
 export { parseRefTarget } from "../engine/parse-ref-target.js";
-export { availableSelectOptions, evalFieldCondition, explicitListScreenId, findUnavailableSelectOptions, isExtensionEditSection, isFieldsEditSection, isFormatSpec, isRecordLocked, isWriteFormEditSection, normalizeEditField, normalizeListColumn, resolveNavParentScreen, sectionFieldSpecs, } from "../engine/screen-helpers.js";
+export { availableSelectOptions, evalFieldCondition, explicitListScreenId, findUnavailableSelectOptions, isExtensionEditSection, isFieldsEditSection, isFormatSpec, isRecordLocked, isUnchangedValue, isWriteFormEditSection, normalizeEditField, normalizeListColumn, resolveNavParentScreen, sectionFieldSpecs, } from "../engine/screen-helpers.js";
 export { isOpenToAllGranted, isUiAccessGranted } from "../engine/types/handlers.js";
 export { metricField, relatedListGroupHeaderLabel, relatedListGroupKey, } from "../engine/types/screen.js";
 export { ACTION_FORM_ENTITY, handlerFieldLabelKey, handlerTitleKey, PROJECTION_DETAIL_ENTITY, WRITE_FORM_SECTION_ENTITY, } from "../i18n/required-surface-keys.js";

package/dist/upgrade-cli.js

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync, } from "node:fs";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { getFlag, getStringFlag, parseArgs } from "./arg-parser.js";
 import { compareVersions, filterEntriesAfter, parseFeatureChangelog, sortEntries, } from "./engine/index.js";
 import { ensureTemporalPolyfill } from "./time/index.js";
 const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+const SEMVER_CORE_RE = /^(\d+\.\d+\.\d+)(?:-[0-9A-Za-z.-]+)?$/;
 const CODEMOD_SUBDIR = "scripts/codemod";
 function readPackageJsonVersion(packageJsonPath) {
     if (!existsSync(packageJsonPath))
@@ -21,20 +22,49 @@ function readPackageJsonVersion(packageJsonPath) {
 }
 // bun.lock pins transitive packages too, so a repo that only depends on
 // kumiko-cli/-guards still records the bundled-features version it resolved.
-function readLockfileVersion(root, pkgName) {
-    const lockPath = join(root, "bun.lock");
+// Prerelease and snapshot pins (0.364.0-next.1, 0.0.0-pr-123) are reduced to
+// their x.y.z core, the only shape the rest of the CLI compares.
+function readLockfileVersion(dir, pkgName) {
+    const lockPath = join(dir, "bun.lock");
     if (!existsSync(lockPath))
         return null;
-    const pinned = new RegExp(`"@cosmicdrift/${pkgName}": \\["@cosmicdrift/${pkgName}@(\\d+\\.\\d+\\.\\d+)"`).exec(readFileSync(lockPath, "utf-8"));
-    return pinned?.[1] ?? null;
+    const pinned = new RegExp(`"@cosmicdrift/${pkgName}": \\["@cosmicdrift/${pkgName}@([^"]+)"`).exec(readFileSync(lockPath, "utf-8"));
+    return pinned?.[1] === undefined ? null : (SEMVER_CORE_RE.exec(pinned[1])?.[1] ?? null);
 }
-// Only the repo's own install, package dir and lockfile count. Walking up
-// from a worktree nested in a parent workspace read that workspace's version,
-// and the isolated linker keeps transitive packages out of node_modules.
+function declaresWorkspaces(packageJsonPath) {
+    if (!existsSync(packageJsonPath))
+        return false;
+    try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return typeof pkg === "object" && pkg !== null && "workspaces" in pkg;
+    }
+    catch {
+        return false;
+    }
+}
+function isRepoBoundary(dir) {
+    return existsSync(join(dir, ".git")) || declaresWorkspaces(join(dir, "package.json"));
+}
+function readPackageVersionAt(dir, pkgName, repoLocalPath) {
+    return (readPackageJsonVersion(join(dir, `node_modules/@cosmicdrift/${pkgName}/package.json`)) ??
+        readPackageJsonVersion(join(dir, repoLocalPath)) ??
+        readLockfileVersion(dir, pkgName));
+}
+// Walks up from a workspace member to the repo's own root (.git or a
+// package.json with workspaces) but never past it: walking on from a worktree
+// nested in a parent workspace read that workspace's version, and the
+// isolated linker keeps transitive packages out of node_modules.
 function readPackageVersion(root, pkgName, repoLocalPath) {
-    return (readPackageJsonVersion(join(root, `node_modules/@cosmicdrift/${pkgName}/package.json`)) ??
-        readPackageJsonVersion(join(root, repoLocalPath)) ??
-        readLockfileVersion(root, pkgName));
+    let dir = root;
+    for (;;) {
+        const version = readPackageVersionAt(dir, pkgName, repoLocalPath);
+        if (version !== null || isRepoBoundary(dir))
+            return version;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
 }
 // Changelog entries come from @cosmicdrift/kumiko-bundled-features (see
 // findFeaturesDirs); comparing against the framework version instead
@@ -508,6 +538,8 @@ markerVersion, previous) {
 function parseResolveInput(args) {
     if (getFlag(args, "apply"))
         return { error: "--resolve cannot be combined with --apply." };
+    if (getFlag(args, "dry-run"))
+        return { error: "--resolve cannot be combined with --dry-run." };
     const refs = (getStringFlag(args, "resolve") ?? "")
         .split(",")
         .map((ref) => ref.trim())
@@ -565,8 +597,9 @@ function resolveManualMigrations(out, args, targetDir) {
     if (errors.length > 0)
         return fail(...errors, "Nothing was written.");
     const { reason } = input;
-    const notApplicableFlag = args.flags.get("not-applicable");
-    const resolution = notApplicableFlag !== undefined && notApplicableFlag !== false ? "not-applicable" : "migrated";
+    const resolution = getFlag(args, "not-applicable")
+        ? "not-applicable"
+        : "migrated";
     const resolvedAt = Temporal.Now.instant().toString();
     const newlyResolved = open
         .filter((entry) => resolvedIds.has(entry.id))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.363.0",
+  "version": "0.365.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -210,8 +210,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-http": "0.363.0",
-    "@cosmicdrift/kumiko-types": "0.363.0",
+    "@cosmicdrift/kumiko-http": "0.365.0",
+    "@cosmicdrift/kumiko-types": "0.365.0",
     "bullmq": "^5.76.7",
     "bun-types": "^1.3.13",
     "hono": "^4.13.1",
@@ -227,7 +227,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.363.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.365.0",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },
@@ -419,6 +419,8 @@
     "src/changes.json",
     "src/scripts/codemod",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "AGENTS.md",
+    "agents"
   ]
 }