@mulmoclaude/core 3.7.0 → 3.11.0

package/dist/{server-B48Jyxcj.js → server-zcM1ViCE.js}

@@ -1,17 +1,15 @@
 import { a as isErrorWithCode, c as isStringArray, l as isUnknownArray, s as isRecord, t as errorMessage } from "./dist-D8zokgGo.js";
 import { n as writeFileAtomic } from "./root-BMroU_mB.js";
 import { n as toPosixRelPath } from "./relPath-DW8MC8VO.js";
-import { F as isFieldDrivenEvery, L as storageKindFor, P as embedTargetId, R as fieldText, j as COMPUTED_TYPES, l as parseIsoDate, u as parseIsoDateTime, y as isValidCollectionName, z as fieldTextOrNull } from "./calendarGrid-CQ8MVSRb.js";
-import { C as actionVisible, _ as uniqueRefTargets, b as projectBacklinkRow, c as selectDynamicRecord, f as itemIsDone, g as uniqueEmbedTargets, h as uniqueBacklinkSources, i as ownProp, n as deriveAll, o as firstDateField, s as resolveIcon, t as defangForPrompt, v as backlinkRows, x as rollupValue, y as coerceNumeric } from "./promptSafety-CpiME8pj.js";
-import { B as SCHEMA_FILE$1, C as resolveCreateItemId, D as loadCollection, E as discoverCollections, I as parseAppManifest, J as isBackendUnavailable, K as safeSlugName, M as resolveMutateSet, N as APP_MANIFEST_FILE, O as resolvePrimaryField, U as resolveDataDir, V as isContainedInRoot, W as resolveTemplatePath, X as archiveDir, at as log, b as isRegularFile, d as normalizeCsvValue, f as queryCsv, h as CollectionQueryZ, i as checkpointSqliteDatabase, j as CollectionSchemaZ, m as compileJsonlQuery, n as readOnlyRefusal, nt as getWorkspaceRoot, o as cacheDir, pt as stagingSkillDir, r as storeFor, rt as isPresetSlug$1, tt as firestoreHandle } from "./store-_61sO8K8.js";
+import { B as fieldText, I as embedTargetId, L as isFieldDrivenEvery, N as COMPUTED_TYPES, V as fieldTextOrNull, d as parseIsoDate, f as parseIsoDateTime, x as isValidCollectionName, z as storageKindFor } from "./itemId-DfTm08jm.js";
+import { C as actionVisible, _ as uniqueRefTargets, b as projectBacklinkRow, c as selectDynamicRecord, f as itemIsDone, g as uniqueEmbedTargets, h as uniqueBacklinkSources, i as ownProp, n as deriveAll, o as firstDateField, s as resolveIcon, t as defangForPrompt, v as backlinkRows, x as rollupValue, y as coerceNumeric } from "./promptSafety-CSdyp7RF.js";
+import { B as SCHEMA_FILE$1, C as CollectionQueryZ, I as parseAppManifest, J as isBackendUnavailable, K as safeSlugName, O as isRegularFile, S as compileJsonlQuery, U as resolveDataDir, V as isContainedInRoot, W as resolveTemplatePath, X as archiveDir, b as queryCsv, c as resolveMutateSet, d as storeFor, f as checkpointSqliteDatabase, ht as stagingSkillDir, i as resolvePrimaryField, it as isPresetSlug$1, j as resolveCreateItemId, m as cacheDir, n as discoverCollections, nt as getWorkspaceRoot, ot as log, r as loadCollection, s as CollectionSchemaZ, u as readOnlyRefusal, y as normalizeCsvValue } from "./discovery-B9zdNkgW.js";
 import { ingestStatePath } from "./feeds/paths.js";
 import { mirrorSkillWrite } from "./skill-bridge/index.js";
 import path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import { cp, lstat, mkdir, open, readFile, readdir, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import { z } from "zod";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 //#region src/collection/server/publishManifest.ts
 /** A collection id / app id, held to the one name rule (`SAFE_SLUG_PATTERN`)
 *  that `sharedCollectionKey` applies. Stated once so a path built later
@@ -124,6 +122,34 @@ var PublicZ = z.object({
 	read: z.array(NameZ).optional(),
 	submit: z.record(NameZ, SubmitZ).optional()
 }).strict();
+/** The URL name an app is handed out under: `https://<host>/{slug}`.
+*
+*  A SEPARATE name from the `aid`, and that separation is the point (design
+*  D2b). `apps/{aid}` is a shelf every user of the deployment shares and the
+*  rules' `allow create` asks only that you name yourself owner — so a
+*  memorable aid is first-come-first-served, cannot be checked for
+*  availability, and frees up again when an app is deleted. The aid is
+*  therefore a UUID, and the thing people can fight over is moved to the name
+*  that costs nothing to change.
+*
+*  Declared here rather than kept beside `app.json` because a RESERVATION has
+*  to travel with the repository: `appSlugs/{slug}` is unreadable until the app
+*  is published (`allow read: if resource.data.published == true`), so nothing
+*  can recover which slug an app holds by asking Firestore. A second file to
+*  keep in step with the declaration is the alternative, and it is the kind of
+*  pair that goes out of step silently.
+*
+*  The shape is stricter than `NameZ` on purpose: it is BOTH a URL path
+*  segment people read aloud and a Firestore document id. Lowercase
+*  alphanumerics separated by single hyphens covers both without a case rule
+*  that would make two slugs collide in one place and not the other.
+*
+*  Which slug an app ended up with is the HOST's business — a wanted slug can
+*  be taken, and the host writes the one it reserved back here. Nothing in this
+*  package reads the key; it is declared so that writing it back does not make
+*  the file unparseable. */
+var SLUG_SHAPE = "must be lowercase letters, digits and single hyphens, and must not start or end with one (e.g. sakura-hair)";
+var SlugZ = z.string().trim().max(64).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/, SLUG_SHAPE).refine((slug) => !slug.includes("--"), SLUG_SHAPE);
 /** The whole authored declaration.
 *
 *  `owner` is accepted but is NOT the published value — publish stamps the
@@ -135,6 +161,8 @@ var PublicZ = z.object({
 var AuthoredAppZ = z.object({
 	aid: NameZ,
 	name: z.string().trim().min(1).optional(),
+	/** The wanted (or reserved) URL name — see {@link SlugZ}. */
+	slug: SlugZ.optional(),
 	/** Per-worktree app id (design D6, implementation order 7). Accepted so a
 	*  repository already carrying it parses; nothing reads it yet. */
 	aidEnv: z.string().trim().min(1).optional(),
@@ -263,6 +291,7 @@ function projectApp(authored, schemas, stamp, existing) {
 		publishedAt: stamp.publishedAt,
 		publishedBy: stamp.email,
 		publishedCommit: stamp.commit,
+		publishedDirty: stamp.dirty === true ? true : void 0,
 		previousPublished: previousOf(existing)
 	});
 	const config = {
@@ -281,6 +310,102 @@ function projectApp(authored, schemas, stamp, existing) {
 		config
 	};
 }
+/** Keys on the app document that publish owns: what is PUBLIC right now, and
+*  the rule-facing configuration anonymous access is judged against. Deploy
+*  carries them through from the existing document and never authors them. */
+var PUBLISH_OWNED_KEYS = [
+	"public",
+	"collections",
+	"participantRead",
+	"publishedAt",
+	"publishedBy",
+	"publishedCommit",
+	"publishedDirty",
+	"previousPublished"
+];
+var isPublishOwned = (key) => PUBLISH_OWNED_KEYS.includes(key);
+function projectDeploy(authored, schemas, stamp, existing) {
+	const { app } = projectApp(authored, schemas, stamp, existing);
+	const deployed = Object.fromEntries(Object.entries(app).filter(([key]) => !isPublishOwned(key)));
+	for (const key of PUBLISH_OWNED_KEYS) {
+		const live = existing?.[key];
+		if (live !== void 0) deployed[key] = live;
+	}
+	deployed.deployedAt = stamp.publishedAt;
+	deployed.deployedBy = stamp.email;
+	if (stamp.commit !== void 0) deployed.deployedCommit = stamp.commit;
+	return {
+		app: deployed,
+		staging: schemas.map(({ cid, schema }) => ({
+			cid,
+			doc: stagedDoc(schema, stamp, authored, cid)
+		}))
+	};
+}
+/** One staged schema document, carrying this cid's rule-facing configuration
+*  alongside the schema so publish can promote them together. */
+function stagedDoc(schema, stamp, authored, cid) {
+	const doc = {
+		publishedSchema: schema,
+		deployedAt: stamp.publishedAt,
+		deployedBy: stamp.email
+	};
+	const config = authored.collections?.[cid];
+	if (config !== void 0) doc.config = config;
+	if (authored.participantRead?.includes(cid) === true) doc.participantRead = true;
+	if (stamp.commit !== void 0) doc.deployedCommit = stamp.commit;
+	return doc;
+}
+/** The rule-facing configuration to promote, read from the STAGED documents
+*  rather than from the manifest as it reads right now.
+*
+*  Otherwise: deploy revision A, edit `app.json` to revision B, publish — and
+*  the promoted schema is A's while the authorization behaviour is B's, a
+*  combination nobody exercised through `/staging/{aid}`.
+*
+*  (`public` is deliberately NOT part of this: it is not staged, because it is
+*  the decision being made AT publish rather than something under test.) */
+function stagedRuleConfig(staged) {
+	const entries = [];
+	const participantRead = [];
+	for (const entry of staged) {
+		const { config } = entry.doc;
+		if (config !== void 0) entries.push([entry.cid, config]);
+		if (entry.doc.participantRead === true) participantRead.push(entry.cid);
+	}
+	return {
+		collections: entries.length > 0 ? Object.fromEntries(entries) : void 0,
+		participantRead: participantRead.length > 0 ? participantRead : void 0
+	};
+}
+function projectPublish(authored, staged, stamp, existing) {
+	const { app, config } = projectApp(authored, [], stamp, existing);
+	const staging = stagedRuleConfig(staged);
+	app.collections = staging.collections;
+	app.participantRead = staging.participantRead;
+	const published = Object.fromEntries(Object.entries(existing ?? app).filter(([key]) => !isPublishOwned(key)));
+	for (const key of PUBLISH_OWNED_KEYS) if (key !== "public" && app[key] !== void 0) published[key] = app[key];
+	const publicBlock = app.public;
+	return {
+		app: published,
+		config,
+		public: isRecord(publicBlock) ? publicBlock : void 0
+	};
+}
+/** Re-stamp a staged schema document as it is promoted to `collections/{cid}`.
+*
+*  The stamp answers "which version is PUBLIC right now, and who made it so",
+*  so it is written by the operation that changes the answer — publish — not
+*  carried over from the deploy that staged it. */
+function promoteSchema(staged, stamp) {
+	const doc = {
+		publishedSchema: staged.publishedSchema,
+		publishedAt: stamp.publishedAt,
+		publishedBy: stamp.email
+	};
+	if (stamp.commit !== void 0) doc.publishedCommit = stamp.commit;
+	return doc;
+}
 /** One published schema document. Written key by key rather than through
 *  `compact`, so the declared type is the type — an optional commit is the
 *  only variable part. */
@@ -296,8 +421,31 @@ function schemaDoc(schema, stamp) {
 /** The app documents' parent path — the `FirestoreDocs` seam takes a
 *  collection path plus a document id, and the app document's id is the aid. */
 var APPS_COLLECTION = "apps";
-/** The collection (schema) documents' parent path. */
+/** The collection (schema) documents' parent path — what the PUBLIC page
+*  reads, written only by publish (promotion). */
 var appSchemasPath = (aid) => `apps/${aid}/collections`;
+/** The URL-slug reservations — `appSlugs/{slug}` → `{ aid, published }`.
+*
+*  A TOP-LEVEL collection, not a field on the app: the public page resolves a
+*  slug to an aid BEFORE it can read anything under `apps/{aid}`, and a slug
+*  has to be claimable atomically (create-if-absent) so two apps cannot hold
+*  the same URL.
+*
+*  `published` is what makes the reservation invisible until publish. The slug
+*  is human-readable, so a readable reservation would let anyone guess the URL
+*  and get the aid — and the aid is the `/staging/{aid}` entrance. The rule is
+*  `allow read: if resource.data.published == true`, which needs no `get()` and
+*  so costs nothing against the rules' expression budget. */
+var APP_SLUGS_COLLECTION = "appSlugs";
+var appSlugDoc = (aid, published) => ({
+	aid,
+	published
+});
+/** The staged schema documents' parent path — what `/staging/{aid}` reads,
+*  written by deploy. A separate DOCUMENT rather than a field beside
+*  `publishedSchema`, because the rules cannot hide a field: anything inside a
+*  document the public page may read is public. */
+var appStagingPath = (aid) => `apps/${aid}/staging`;
 /** The public-config documents' parent path. */
 var appConfigPath = (aid) => `apps/${aid}/config`;
 //#endregion
@@ -523,530 +671,32 @@ function publishProblems(app, collections, publisherEmail) {
 		...primaryKeyProblems(app, collections)
 	];
 }
-/** A public submission must be able to produce a record the HOST can read.
-*
-*  The rules and the engine disagree about what identifies a record, and the
-*  gap is invisible from either side alone. The rules bind the DOCUMENT ID
-*  (`idFrom`) and let a submission carry only `createFields`; the engine
-*  identifies a record by its schema's `primaryKey` FIELD, and the firestore
-*  store hands back the document's fields verbatim — `toItem` does not
-*  synthesize the key from the document id. So a submit path whose
-*  `createFields` omits the primary key writes rows that Firestore accepts and
-*  every reader rejects: `validateRecordObject` fails them, the collection
-*  renders empty-ish, and the next publish's own pre-check reports them as
-*  broken records the publisher never wrote.
-*
-*  Not checkable by the rules (they have never heard of a schema) and not
-*  catchable at write time (nothing is wrong with the write). Publish is the
-*  only place that holds both halves. */
-function primaryKeyProblems(app, collections) {
-	const primaryKeyOf = new Map(collections.map((collection) => [collection.cid, collection.primaryKey]));
-	return Object.entries(app.public?.submit ?? {}).flatMap(([cid, submit]) => {
-		const primaryKey = primaryKeyOf.get(cid);
-		if (primaryKey === void 0 || submit.createFields.includes(primaryKey)) return [];
-		return [`public.submit.${cid}.createFields must include "${primaryKey}", the schema's primaryKey: a submission may carry only the createFields, and a shared record is stored as exactly the fields it was written with — the document id is not copied into the record. Without it every submission is accepted by the rules and then rejected by every reader.`];
-	});
-}
-//#endregion
-//#region src/collection/core/recordZ.ts
-/** The emptiness rule shared by `required` and the "only check present
-*  values" gate. NOT a truthiness check — `0` and `false` are filled. */
-var isEmptyValue = (value) => value === void 0 || value === null || value === "";
-/** The historical write-gate checks, verbatim: required non-empty, enum
-*  membership (compared as strings, so a numeric `5` satisfies `"5"`). */
-function enforcedProblem(key, spec, value) {
-	const empty = isEmptyValue(value);
-	if (spec.required && empty) return `missing required field '${key}'`;
-	if (!empty && spec.type === "enum" && !spec.values.includes(String(value))) return `'${key}' = '${String(value)}' is not one of [${spec.values.join(", ")}]`;
-	return null;
-}
-/** Report-only per-type checks on a PRESENT value. Date / datetime reuse the
-*  calendar's STRICT civil parsers (`parseIsoDate` / `parseIsoDateTime`), so
-*  the lint flags exactly the values the calendar / trigger / spawn code
-*  would silently drop — impossible days like `2026-02-30`, and datetimes
-*  outside the canonical `YYYY-MM-DDTHH:MM[:SS]` shape (e.g. a `Z` suffix,
-*  which the day view can't place). `string`-backed types accept anything
-*  stringifiable; `ref` existence is out of scope. */
-function strictTypeProblem(key, spec, value) {
-	switch (spec.type) {
-		case "number":
-		case "money": return Number.isFinite(coerceNumeric(value)) ? null : `'${key}' = '${String(value)}' is not numeric (a '${spec.type}' field stores a plain number)`;
-		case "boolean": return value === true || value === false ? null : `'${key}' = '${String(value)}' is not a boolean (store true or false, unquoted)`;
-		case "date": return parseIsoDate(value) !== null ? null : `'${key}' = '${String(value)}' is not a real YYYY-MM-DD date`;
-		case "datetime": return parseIsoDateTime(value) !== null ? null : `'${key}' = '${String(value)}' is not a YYYY-MM-DDTHH:MM datetime (seconds optional, no timezone suffix — the shape the calendar parses)`;
-		default: return null;
-	}
-}
-/** Strict check for a PRESENT `table` value: an array of row objects, each
-*  row conforming to the sub-schema (required / enum / typed sub-values).
-*  First row problem wins, prefixed with the row number so the fix is
-*  locatable. */
-function strictTableProblem(key, spec, value) {
-	if (!Array.isArray(value)) return `'${key}' = '${String(value)}' is not an array of rows (a 'table' field stores an array of row objects)`;
-	for (let index = 0; index < value.length; index++) {
-		const row = value[index];
-		if (!isRecord(row)) return `'${key}' row ${index + 1} is not an object`;
-		for (const [subKey, subSpec] of Object.entries(spec.of)) {
-			const subValue = row[subKey];
-			const problem = enforcedProblem(subKey, subSpec, subValue) ?? (isEmptyValue(subValue) ? null : strictTypeProblem(subKey, subSpec, subValue));
-			if (problem) return `'${key}' row ${index + 1}: ${problem}`;
-		}
-	}
-	return null;
-}
-/** First problem for one field's stored value under `tier`, or null.
-*  Enforced checks always run (and their messages never vary by tier — the
-*  scan and the write gate must agree on them); strict adds the per-type
-*  layer on present values only. */
-function recordFieldProblem(key, spec, value, tier) {
-	const enforced = enforcedProblem(key, spec, value);
-	if (enforced || tier === "enforced") return enforced;
-	if (isEmptyValue(value)) return null;
-	if (spec.type === "table") return strictTableProblem(key, spec, value);
-	return strictTypeProblem(key, spec, value);
-}
-var compiled = /* @__PURE__ */ new WeakMap();
-/** Compile `schema.fields` into a zod validator for a stored record.
-*  Loose object: unknown keys are allowed and any declared key may be
-*  absent (records are user files, not parse-and-rewrite targets —
-*  callers validate, they never persist the parse output). The checks run
-*  as ONE object-level refine iterating fields in declaration order —
-*  per-key shape schemas can't express "key may be absent BUT its absence
-*  must still reach the required check", and the single loop keeps the
-*  first reported issue identical to the historical first-problem-wins
-*  contract. */
-function compileRecordZ(schema, tier) {
-	const cached = compiled.get(schema)?.[tier];
-	if (cached) return cached;
-	const stored = Object.entries(schema.fields).filter(([, spec]) => !COMPUTED_TYPES.has(spec.type));
-	const validator = z.looseObject({}).superRefine((record, ctx) => {
-		for (const [key, spec] of stored) {
-			const problem = recordFieldProblem(key, spec, record[key], tier);
-			if (problem) ctx.addIssue({
-				code: "custom",
-				message: problem,
-				path: [key]
-			});
-		}
-	});
-	const entry = compiled.get(schema) ?? {};
-	entry[tier] = validator;
-	compiled.set(schema, entry);
-	return validator;
-}
-/** First schema problem on an in-memory record under `tier`, or null. One
-*  issue per record keeps the report short and the fix obvious (the
-*  historical contract of `validateRecordObject`). */
-function firstRecordProblem(record, schema, tier) {
-	const result = compileRecordZ(schema, tier).safeParse(record);
-	if (result.success) return null;
-	return result.error.issues[0]?.message ?? "record failed schema validation";
-}
-//#endregion
-//#region src/collection/server/validate.ts
-/** Don't flood the result; the first batch is enough to act on. Exported
-*  because a caller that REPORTS a count has to know the count is a floor —
-*  `publish` presents a full batch as "at least N" rather than as a total. */
-var MAX_RECORD_ISSUES = 25;
-/** The `file` of the pseudo-issue reported when the backend could not be read
-*  at all.
-*
-*  Exported because it is a DIFFERENT KIND of answer from "this record is
-*  invalid", and a caller that treats the two alike gets it wrong in the
-*  direction that matters: `publish` lets the user override invalid records,
-*  and overriding this one would mean publishing without ever having looked. */
-var STORE_UNREADABLE = "(store)";
-var MAX_ISSUES = 25;
-/** Read every `<id>.json` under the collection's dataDir and report the
-*  ones that won't load or violate the schema. An empty list means every
-*  record is fine. */
-/** List entries under the data dir, guarding realpath containment (against a
-*  symlinked dir swapped in after discovery, like `listItems`) and treating a
-*  missing dir as empty while surfacing real I/O faults. */
-async function listRecordFilenames(dataDir, workspaceRoot) {
-	if (!isContainedInRoot(dataDir, workspaceRoot)) {
-		log.warn("collections", "validate refused: dataDir escapes workspace via symlink", { dataDir });
-		return [];
-	}
-	try {
-		return await readdir(dataDir);
-	} catch (err) {
-		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
-		throw err;
-	}
-}
-async function validateCollectionRecords(collection, opts = {}) {
-	if (collection.schema.dataSource !== void 0) return [];
-	if (collection.schema.storage !== void 0) return validateStoreRecords(collection, opts);
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	const entries = await listRecordFilenames(collection.dataDir, workspaceRoot);
-	const issues = [];
-	for (const name of entries.sort()) {
-		if (!name.endsWith(".json") || name.startsWith(".")) continue;
-		if (issues.length >= MAX_ISSUES) break;
-		const issue = await inspectRecord(path.join(collection.dataDir, name), name, collection.schema);
-		if (issue) issues.push(issue);
-	}
-	return issues;
-}
-/** Store-backed twin of the file scan: list every record through the
-*  collection's store and lint it with the same "strict" report-only tier.
-*  A row the store can't even parse is invisible here (the store skips
-*  it), so the read/parse classifications of the file scan don't apply —
-*  schema violations are what this catches. `file` carries the record id
-*  (there is no per-record filename). */
-async function validateStoreRecords(collection, opts) {
-	let items;
-	try {
-		items = await storeFor(collection, { workspaceRoot: opts.workspaceRoot }).list();
-	} catch (err) {
-		return [{
-			file: STORE_UNREADABLE,
-			problem: `records could not be read from the storage backend: ${err instanceof Error ? err.message : String(err)}`
-		}];
-	}
-	const issues = [];
-	for (const item of items) {
-		if (issues.length >= MAX_ISSUES) break;
-		const itemId = fieldText(item[collection.schema.primaryKey]);
-		const problem = validateRecordObject(item, itemId, collection.schema, "strict");
-		if (problem) issues.push({
-			file: itemId,
-			problem
-		});
-	}
-	return issues;
-}
-async function readRecordText(fullPath, name) {
-	try {
-		if (!(await lstat(fullPath)).isFile()) return {
-			file: name,
-			problem: "not a regular file (symlink?) — skipped, won't appear"
-		};
-		return { raw: await readFile(fullPath, "utf-8") };
-	} catch {
-		return {
-			file: name,
-			problem: "could not be read — skipped, won't appear"
-		};
-	}
-}
-/** Classify a single record file: unreadable / unparseable / non-object /
-*  schema violation, or null when it's fine. */
-async function inspectRecord(fullPath, name, schema) {
-	const read = await readRecordText(fullPath, name);
-	if ("problem" in read) return read;
-	let parsed;
-	try {
-		parsed = JSON.parse(read.raw);
-	} catch (err) {
-		return {
-			file: name,
-			problem: `invalid JSON (${err instanceof Error ? err.message : String(err)}) — SKIPPED, won't appear. Usual cause: an unescaped " inside a string value; use 「」/『』 or write \\" instead.`
-		};
-	}
-	if (!isRecord(parsed)) return {
-		file: name,
-		problem: "not a JSON object — skipped, won't appear"
-	};
-	const problem = validateRecordObject(parsed, name.replace(/\.json$/, ""), schema, "strict");
-	return problem ? {
-		file: name,
-		problem
-	} : null;
-}
-/** What a non-string primary key actually is, for the error message. Names the
-*  shape rather than stringifying the value — "[object Object]" tells the reader
-*  nothing about what is wrong. */
-function describeIdType(value) {
-	if (value === null) return "null";
-	if (value === void 0) return "missing";
-	if (Array.isArray(value)) return "an array";
-	return `a ${typeof value}`;
-}
-/** First schema problem on an in-memory record (primaryKey↔id mismatch,
-*  then the compiled per-field checks — see `../core/recordZ` for the two
-*  tiers), or null when it's fine. One issue per record keeps the report
-*  short and the fix obvious. Pure + exported so write paths
-*  (manageCollection putItems) can gate on the SAME enforced rules the
-*  post-hoc file scan reports — `itemId` is the id the record is (or
-*  would be) stored under. The default `"enforced"` tier keeps every
-*  write gate on the historical three checks; only pass `"strict"` from
-*  report-only surfaces. */
-function validateRecordObject(record, itemId, schema, tier = "enforced") {
-	const idValue = record[schema.primaryKey];
-	if (typeof idValue !== "string") return `'${schema.primaryKey}' must be a string, but is ${describeIdType(idValue)} — must equal the filename ('${itemId}'), or the record can't be opened`;
-	if (idValue !== itemId) return `'${schema.primaryKey}' is '${idValue}' but must equal the filename ('${itemId}'), or the record can't be opened`;
-	return firstRecordProblem(record, schema, tier);
-}
-//#endregion
-//#region src/collection/server/publish.ts
-var execFileAsync = promisify(execFile);
-/** How many broken records to name before summarising. A publish that would
-*  break a thousand rows is answered by the count and a sample; dumping all of
-*  them buries the number, which is the part the decision turns on. */
-var MAX_LISTED_ISSUES = 10;
-/** `git rev-parse HEAD` plus a dirty check, or nothing.
-*
-*  A missing git, a repository with no commits and a non-repository are all
-*  the same answer here — no commit — because the stamp is attribution, not a
-*  requirement. What is NOT acceptable is a stamp that lies, which is why the
-*  dirty flag exists: publishing from a modified tree records a commit that
-*  does not describe what was published, and the flag is the only thing that
-*  would ever tell a reader so. */
-async function gitStamp(root) {
-	try {
-		const { stdout } = await execFileAsync("git", [
-			"-C",
-			root,
-			"rev-parse",
-			"HEAD"
-		]);
-		const commit = stdout.trim();
-		const { stdout: status } = await execFileAsync("git", [
-			"-C",
-			root,
-			"status",
-			"--porcelain"
-		]);
-		return {
-			commit: commit.length > 0 ? commit : void 0,
-			dirty: status.trim().length > 0
-		};
-	} catch {
-		return {};
-	}
-}
-/** The shared collections of THIS REPOSITORY, by cid.
-*
-*  `userSkillsDir: null` — not a test convenience, a boundary. Discovery
-*  resolves every schema it finds against the WORKSPACE root, user-scope
-*  included, so a globally installed skill under `~/.claude/skills` carrying
-*  `storage.type: "firestore"` picks up whichever repository's `aid` it
-*  happens to be discovered from. Left in, publish would write that schema
-*  into this app — and into every other app the same user publishes, since the
-*  skill is installed once per machine and the repositories are not.
-*
-*  An app is a REPOSITORY (design D1): its collections are the ones committed
-*  beside its `app.json`, which is what makes a clone resolve the same
-*  collections and an invitation a matter of authorization rather than
-*  discovery. A schema that is not in the repository has no claim on a cid
-*  there. And because a view is HTML, publishing one is not a tidiness
-*  question: it is the machine's own skills reaching every member's browser.
-*
-*  The consequence is deliberate: a cid named in `app.json` that exists only
-*  in user scope is now an unknown cid, and publish says so by name instead of
-*  quietly publishing a schema from outside the repository. */
-async function sharedCollections(opts, root) {
-	return (await discoverCollections({
-		...opts,
-		workspaceRoot: root,
-		userSkillsDir: null
-	})).filter((collection) => collection.appId !== void 0);
-}
-/** Existing records that would not satisfy the schema about to be published.
-*
-*  Read from FIRESTORE, not from disk: a shared collection's records live in
-*  the app, and the question this answers is "what does the live data look
-*  like under the new schema" — which is the migration question. Reported as
-*  a refusal the publisher can override, because a breaking change is
-*  sometimes exactly what is intended and the point is that it is a decision
-*  rather than a discovery. */
-async function recordProblems(collections, opts) {
-	const lines = [];
-	const unreadable = [];
-	let records = 0;
-	let cappedAnywhere = false;
-	for (const collection of collections) {
-		const issues = await validateCollectionRecords(collection, opts);
-		if (issues.length === 0) continue;
-		const unread = issues.filter((issue) => issue.file === STORE_UNREADABLE);
-		if (unread.length > 0) {
-			unreadable.push(`${collection.slug}: ${unread.map((issue) => issue.problem).join("; ")}`);
-			continue;
-		}
-		records += issues.length;
-		const capped = issues.length >= 25;
-		cappedAnywhere = cappedAnywhere || capped;
-		const count = capped ? `at least ${issues.length}` : String(issues.length);
-		const plural = issues.length === 1 ? "" : "s";
-		const note = capped ? " (the scan stops there)" : "";
-		lines.push(`${collection.slug}: ${count} existing record${plural} would not satisfy the schema about to be published${note}`);
-		for (const issue of issues.slice(0, MAX_LISTED_ISSUES)) lines.push(`  - ${issue.file}: ${issue.problem}`);
-		if (issues.length > MAX_LISTED_ISSUES) lines.push(`  - … and ${issues.length - MAX_LISTED_ISSUES} more`);
-	}
-	return {
-		lines,
-		records,
-		capped: cappedAnywhere,
-		unreadable
-	};
-}
-function schemasOf(collections) {
-	return collections.map((collection) => ({
-		cid: collection.slug,
-		schema: collection.schema
-	})).sort((left, right) => left.cid < right.cid ? -1 : left.cid > right.cid ? 1 : 0);
-}
-/** Read and parse `<root>/app.json`'s full declaration. */
-async function readAuthored(root) {
-	let raw;
-	try {
-		raw = await readFile(path.join(root, APP_MANIFEST_FILE), "utf-8");
-	} catch (err) {
-		return {
-			ok: false,
-			problems: [`cannot read ${path.join(root, APP_MANIFEST_FILE)}: ${String(err)}`]
-		};
-	}
-	return parseAuthoredApp(raw);
-}
-/** Everything wrong with the declaration itself, publisher included. */
-function declarationProblems(app, collections, handle) {
-	const problems = publishProblems(app, collections.map((collection) => ({
-		cid: collection.slug,
-		primaryKey: collection.schema.primaryKey
-	})), handle.email);
-	if (app.owner !== void 0 && app.owner !== handle.uid) problems.push(`app.json declares owner "${app.owner}", which is not your uid (${handle.uid}). \`owner\` is stamped by publish and carried forward unchanged afterwards — remove it from app.json rather than maintaining it by hand.`);
-	return problems;
-}
-/** Put the three kinds of document, in the order the rules require, and turn a
-*  rejected write into the result type instead of letting it escape.
-*
-*  Returns null when everything was written; a failure result otherwise.
-*
-*  A raw rejection here would reach the agent as a tool crash rather than the
-*  actionable text this tool promises. But "actionable" is a strong claim for
-*  a half-finished publish, so the message ENUMERATES what landed rather than
-*  summarising it: the order is app → every schema → config, and a summary
-*  written for one failure point is wrong at the others. Saying "the roster
-*  and configuration are live" after a SCHEMA write failed names a config
-*  document this publish never wrote — which still holds whatever the last
-*  publish left, and is exactly the state the caller is trying to repair. */
-async function writeDocuments(handle, aid, published) {
-	const steps = [
-		{
-			what: `the app document (apps/${aid})`,
-			run: () => handle.docs.set(APPS_COLLECTION, aid, published.app)
-		},
-		...published.schemas.map(({ cid, doc }) => ({
-			what: `the published schema for '${cid}'`,
-			run: () => handle.docs.set(appSchemasPath(aid), cid, doc)
-		})),
-		{
-			what: `the public config document (apps/${aid}/config/${PUBLIC_CONFIG_DOC})`,
-			run: () => handle.docs.set(appConfigPath(aid), PUBLIC_CONFIG_DOC, published.config)
-		}
-	];
-	const landed = [];
-	for (const [index, step] of steps.entries()) try {
-		await step.run();
-		landed.push(step.what);
-	} catch (err) {
-		const reason = err instanceof Error ? err.message : String(err);
-		return {
-			ok: false,
-			partial: index > 0,
-			problems: [`publish failed while writing ${step.what}: ${reason}`, ...partialState(landed, [step.what, ...steps.slice(index + 1).map((rest) => rest.what)])]
-		};
-	}
-	return null;
-}
-/** What is live and what is not, listed rather than summarised.
-*
-*  Two facts, and both matter for the repair: a document this publish wrote is
-*  live NOW, and a document it did not write still holds what the LAST publish
-*  left — which is not the same as being absent, and not the same as matching
-*  the declaration that was just half-applied. */
-function partialState(landed, notWritten) {
-	const repair = "Publishing again is the repair: the write is idempotent, and it re-does every step, including the ones that did land.";
-	if (landed.length === 0) return [`Nothing was written. ${repair}`];
-	return [
-		`Written by this publish, and live now: ${landed.join("; ")}.`,
-		`NOT written: ${notWritten.join("; ")} — ${notWritten.length === 1 ? "it still holds" : "they still hold"} whatever the previous publish left.`,
-		repair
-	];
-}
-/** Publish this repository's declaration to its app.
-*
-*  Everything variable is a parameter or comes from the host binding, so the
-*  whole path is exercisable against an in-memory `FirestoreDocs` with no
-*  network and no API key — which is the only way the conversion table gets
-*  tested as a table. */
-async function publishApp(opts = {}) {
-	const root = opts.workspaceRoot ?? getWorkspaceRoot();
-	const handle = firestoreHandle();
-	if (!handle) return {
-		ok: false,
-		partial: false,
-		problems: ["publish needs a signed-in Firestore session: connect remote-host first. Publishing writes the app's roster and configuration as the app's owner, which is an authenticated write."]
-	};
-	const authored = await readAuthored(root);
-	if (!authored.ok) return {
-		...authored,
-		partial: false
-	};
-	const collections = await sharedCollections(opts, root);
-	const problems = declarationProblems(authored.app, collections, handle);
-	if (problems.length > 0) return {
-		ok: false,
-		partial: false,
-		problems
-	};
-	const issues = await recordProblems(collections, {
-		...opts,
-		workspaceRoot: root
-	});
-	if (issues.unreadable.length > 0) return {
-		ok: false,
-		partial: false,
-		problems: [...issues.unreadable, "publish stopped: the live records could not be read, so nothing checked whether the schemas about to be published still fit them. This is not something `confirm` overrides — confirming means accepting a known breakage, and here there is no reading at all. Fix the access (or the connection) and publish again."]
-	};
-	if (issues.records > 0 && opts.confirm !== true) return {
-		ok: false,
-		partial: false,
-		problems: [...issues.lines, "publish stopped: these records are live and members are reading them. Migrate them first, or re-run with confirm to publish the schema anyway and repair the records afterwards."]
-	};
-	return writePublished(authored.app, collections, handle, opts, root, issues);
-}
-/** The write half: stamp, project, and put the documents in the order the
-*  rules require. Split from the gate above so neither half hides the other —
-*  everything up to here can refuse, and nothing from here on does. */
-async function writePublished(authored, collections, handle, opts, root, issues) {
-	const { aid } = authored;
-	let existing;
-	try {
-		existing = await handle.docs.get(APPS_COLLECTION, aid);
-	} catch (err) {
-		return {
-			ok: false,
-			partial: false,
-			problems: [`publish failed while reading the current app document (apps/${aid}): ${err instanceof Error ? err.message : String(err)}`, "Nothing was written. Publishing again is safe — this read only decides whether the app is created or updated."]
-		};
-	}
-	const stampSource = await (opts.resolveCommit ?? gitStamp)(root);
-	const stamp = {
-		uid: handle.uid,
-		email: handle.email,
-		publishedAt: (opts.now ?? Date.now)(),
-		commit: stampSource.commit
-	};
-	const existingApp = isRecord(existing) ? existing : null;
-	const published = projectApp(authored, schemasOf(collections), stamp, existingApp);
-	if (stampSource.dirty === true) published.app.publishedDirty = true;
-	const written = await writeDocuments(handle, aid, published);
-	if (written !== null) return written;
-	return {
-		ok: true,
-		aid,
-		cids: published.schemas.map((entry) => entry.cid),
-		created: existingApp === null,
-		commit: stamp.commit,
-		dirty: stampSource.dirty === true,
-		recordIssues: issues.records,
-		recordIssuesCapped: issues.capped,
-		published
-	};
+/** A public submission must NOT be allowed to name its own primary key.
+*
+*  The rules constrain the DOCUMENT ID (`idFrom`) and cannot constrain the
+*  value of a field — nothing compares `request.resource.data[primaryKey]`
+*  with the path being written. So a submit path that accepts the primary key
+*  as a `createField` lets a submitter write at their one permitted document
+*  id while CLAIMING another record's identity, or a duplicate.
+*
+*  It is refused rather than tolerated because there is nothing for the field
+*  to do: `firestoreStore` takes a shared record's identity from the document
+*  id and overwrites the field on read, so a submitted value is either equal
+*  to the id (noise) or a lie (silently discarded). Publishing a form field
+*  whose value is thrown away is worse than not having it — the author will
+*  believe submitters choose their ids.
+*
+*  This is the second answer to the same question. The first was the reverse —
+*  REQUIRE the key, because a record without one was rejected by every reader
+*  — and it was right about the symptom and wrong about the cure: the identity
+*  belongs to the id the rules can pin, not to a field they cannot. */
+function primaryKeyProblems(app, collections) {
+	const primaryKeyOf = new Map(collections.map((collection) => [collection.cid, collection.primaryKey]));
+	return Object.entries(app.public?.submit ?? {}).flatMap(([cid, submit]) => {
+		const primaryKey = primaryKeyOf.get(cid);
+		if (primaryKey === void 0 || !submit.createFields.includes(primaryKey)) return [];
+		return [`public.submit.${cid}.createFields must NOT include "${primaryKey}", the schema's primaryKey: the rules can pin the document id but not the value of a field, so a submitter could write at their own id while claiming another record's. A shared record's identity is its document id — the store fills the field from it, and a submitted value is either the same thing or a lie that is thrown away.`];
+	});
 }
 //#endregion
 //#region src/collection/server/skillAssets.ts
@@ -1412,6 +1062,238 @@ async function runCollectionQuery(collection, query, opts = {}) {
 	return runQueryOverRows(await enrichItems(collection, await store.list(), opts), query);
 }
 //#endregion
+//#region src/collection/core/recordZ.ts
+/** The emptiness rule shared by `required` and the "only check present
+*  values" gate. NOT a truthiness check — `0` and `false` are filled. */
+var isEmptyValue = (value) => value === void 0 || value === null || value === "";
+/** The historical write-gate checks, verbatim: required non-empty, enum
+*  membership (compared as strings, so a numeric `5` satisfies `"5"`). */
+function enforcedProblem(key, spec, value) {
+	const empty = isEmptyValue(value);
+	if (spec.required && empty) return `missing required field '${key}'`;
+	if (!empty && spec.type === "enum" && !spec.values.includes(String(value))) return `'${key}' = '${String(value)}' is not one of [${spec.values.join(", ")}]`;
+	return null;
+}
+/** Report-only per-type checks on a PRESENT value. Date / datetime reuse the
+*  calendar's STRICT civil parsers (`parseIsoDate` / `parseIsoDateTime`), so
+*  the lint flags exactly the values the calendar / trigger / spawn code
+*  would silently drop — impossible days like `2026-02-30`, and datetimes
+*  outside the canonical `YYYY-MM-DDTHH:MM[:SS]` shape (e.g. a `Z` suffix,
+*  which the day view can't place). `string`-backed types accept anything
+*  stringifiable; `ref` existence is out of scope. */
+function strictTypeProblem(key, spec, value) {
+	switch (spec.type) {
+		case "number":
+		case "money": return Number.isFinite(coerceNumeric(value)) ? null : `'${key}' = '${String(value)}' is not numeric (a '${spec.type}' field stores a plain number)`;
+		case "boolean": return value === true || value === false ? null : `'${key}' = '${String(value)}' is not a boolean (store true or false, unquoted)`;
+		case "date": return parseIsoDate(value) !== null ? null : `'${key}' = '${String(value)}' is not a real YYYY-MM-DD date`;
+		case "datetime": return parseIsoDateTime(value) !== null ? null : `'${key}' = '${String(value)}' is not a YYYY-MM-DDTHH:MM datetime (seconds optional, no timezone suffix — the shape the calendar parses)`;
+		default: return null;
+	}
+}
+/** Strict check for a PRESENT `table` value: an array of row objects, each
+*  row conforming to the sub-schema (required / enum / typed sub-values).
+*  First row problem wins, prefixed with the row number so the fix is
+*  locatable. */
+function strictTableProblem(key, spec, value) {
+	if (!Array.isArray(value)) return `'${key}' = '${String(value)}' is not an array of rows (a 'table' field stores an array of row objects)`;
+	for (let index = 0; index < value.length; index++) {
+		const row = value[index];
+		if (!isRecord(row)) return `'${key}' row ${index + 1} is not an object`;
+		for (const [subKey, subSpec] of Object.entries(spec.of)) {
+			const subValue = row[subKey];
+			const problem = enforcedProblem(subKey, subSpec, subValue) ?? (isEmptyValue(subValue) ? null : strictTypeProblem(subKey, subSpec, subValue));
+			if (problem) return `'${key}' row ${index + 1}: ${problem}`;
+		}
+	}
+	return null;
+}
+/** First problem for one field's stored value under `tier`, or null.
+*  Enforced checks always run (and their messages never vary by tier — the
+*  scan and the write gate must agree on them); strict adds the per-type
+*  layer on present values only. */
+function recordFieldProblem(key, spec, value, tier) {
+	const enforced = enforcedProblem(key, spec, value);
+	if (enforced || tier === "enforced") return enforced;
+	if (isEmptyValue(value)) return null;
+	if (spec.type === "table") return strictTableProblem(key, spec, value);
+	return strictTypeProblem(key, spec, value);
+}
+var compiled = /* @__PURE__ */ new WeakMap();
+/** Compile `schema.fields` into a zod validator for a stored record.
+*  Loose object: unknown keys are allowed and any declared key may be
+*  absent (records are user files, not parse-and-rewrite targets —
+*  callers validate, they never persist the parse output). The checks run
+*  as ONE object-level refine iterating fields in declaration order —
+*  per-key shape schemas can't express "key may be absent BUT its absence
+*  must still reach the required check", and the single loop keeps the
+*  first reported issue identical to the historical first-problem-wins
+*  contract. */
+function compileRecordZ(schema, tier) {
+	const cached = compiled.get(schema)?.[tier];
+	if (cached) return cached;
+	const stored = Object.entries(schema.fields).filter(([, spec]) => !COMPUTED_TYPES.has(spec.type));
+	const validator = z.looseObject({}).superRefine((record, ctx) => {
+		for (const [key, spec] of stored) {
+			const problem = recordFieldProblem(key, spec, record[key], tier);
+			if (problem) ctx.addIssue({
+				code: "custom",
+				message: problem,
+				path: [key]
+			});
+		}
+	});
+	const entry = compiled.get(schema) ?? {};
+	entry[tier] = validator;
+	compiled.set(schema, entry);
+	return validator;
+}
+/** First schema problem on an in-memory record under `tier`, or null. One
+*  issue per record keeps the report short and the fix obvious (the
+*  historical contract of `validateRecordObject`). */
+function firstRecordProblem(record, schema, tier) {
+	const result = compileRecordZ(schema, tier).safeParse(record);
+	if (result.success) return null;
+	return result.error.issues[0]?.message ?? "record failed schema validation";
+}
+//#endregion
+//#region src/collection/server/validate.ts
+/** Don't flood the result; the first batch is enough to act on. Exported
+*  because a caller that REPORTS a count has to know the count is a floor —
+*  `publish` presents a full batch as "at least N" rather than as a total. */
+var MAX_RECORD_ISSUES = 25;
+/** The `file` of the pseudo-issue reported when the backend could not be read
+*  at all.
+*
+*  Exported because it is a DIFFERENT KIND of answer from "this record is
+*  invalid", and a caller that treats the two alike gets it wrong in the
+*  direction that matters: `publish` lets the user override invalid records,
+*  and overriding this one would mean publishing without ever having looked. */
+var STORE_UNREADABLE = "(store)";
+var MAX_ISSUES = 25;
+/** Read every `<id>.json` under the collection's dataDir and report the
+*  ones that won't load or violate the schema. An empty list means every
+*  record is fine. */
+/** List entries under the data dir, guarding realpath containment (against a
+*  symlinked dir swapped in after discovery, like `listItems`) and treating a
+*  missing dir as empty while surfacing real I/O faults. */
+async function listRecordFilenames(dataDir, workspaceRoot) {
+	if (!isContainedInRoot(dataDir, workspaceRoot)) {
+		log.warn("collections", "validate refused: dataDir escapes workspace via symlink", { dataDir });
+		return [];
+	}
+	try {
+		return await readdir(dataDir);
+	} catch (err) {
+		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
+		throw err;
+	}
+}
+async function validateCollectionRecords(collection, opts = {}) {
+	if (collection.schema.dataSource !== void 0) return [];
+	if (collection.schema.storage !== void 0) return validateStoreRecords(collection, opts);
+	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
+	const entries = await listRecordFilenames(collection.dataDir, workspaceRoot);
+	const issues = [];
+	for (const name of entries.sort()) {
+		if (!name.endsWith(".json") || name.startsWith(".")) continue;
+		if (issues.length >= MAX_ISSUES) break;
+		const issue = await inspectRecord(path.join(collection.dataDir, name), name, collection.schema);
+		if (issue) issues.push(issue);
+	}
+	return issues;
+}
+/** Store-backed twin of the file scan: list every record through the
+*  collection's store and lint it with the same "strict" report-only tier.
+*  A row the store can't even parse is invisible here (the store skips
+*  it), so the read/parse classifications of the file scan don't apply —
+*  schema violations are what this catches. `file` carries the record id
+*  (there is no per-record filename). */
+async function validateStoreRecords(collection, opts) {
+	let items;
+	try {
+		items = await storeFor(collection, { workspaceRoot: opts.workspaceRoot }).list();
+	} catch (err) {
+		return [{
+			file: STORE_UNREADABLE,
+			problem: `records could not be read from the storage backend: ${err instanceof Error ? err.message : String(err)}`
+		}];
+	}
+	const issues = [];
+	for (const item of items) {
+		if (issues.length >= MAX_ISSUES) break;
+		const itemId = fieldText(item[collection.schema.primaryKey]);
+		const problem = validateRecordObject(item, itemId, collection.schema, "strict");
+		if (problem) issues.push({
+			file: itemId,
+			problem
+		});
+	}
+	return issues;
+}
+async function readRecordText(fullPath, name) {
+	try {
+		if (!(await lstat(fullPath)).isFile()) return {
+			file: name,
+			problem: "not a regular file (symlink?) — skipped, won't appear"
+		};
+		return { raw: await readFile(fullPath, "utf-8") };
+	} catch {
+		return {
+			file: name,
+			problem: "could not be read — skipped, won't appear"
+		};
+	}
+}
+/** Classify a single record file: unreadable / unparseable / non-object /
+*  schema violation, or null when it's fine. */
+async function inspectRecord(fullPath, name, schema) {
+	const read = await readRecordText(fullPath, name);
+	if ("problem" in read) return read;
+	let parsed;
+	try {
+		parsed = JSON.parse(read.raw);
+	} catch (err) {
+		return {
+			file: name,
+			problem: `invalid JSON (${err instanceof Error ? err.message : String(err)}) — SKIPPED, won't appear. Usual cause: an unescaped " inside a string value; use 「」/『』 or write \\" instead.`
+		};
+	}
+	if (!isRecord(parsed)) return {
+		file: name,
+		problem: "not a JSON object — skipped, won't appear"
+	};
+	const problem = validateRecordObject(parsed, name.replace(/\.json$/, ""), schema, "strict");
+	return problem ? {
+		file: name,
+		problem
+	} : null;
+}
+/** What a non-string primary key actually is, for the error message. Names the
+*  shape rather than stringifying the value — "[object Object]" tells the reader
+*  nothing about what is wrong. */
+function describeIdType(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "missing";
+	if (Array.isArray(value)) return "an array";
+	return `a ${typeof value}`;
+}
+/** First schema problem on an in-memory record (primaryKey↔id mismatch,
+*  then the compiled per-field checks — see `../core/recordZ` for the two
+*  tiers), or null when it's fine. One issue per record keeps the report
+*  short and the fix obvious. Pure + exported so write paths
+*  (manageCollection putItems) can gate on the SAME enforced rules the
+*  post-hoc file scan reports — `itemId` is the id the record is (or
+*  would be) stored under. The default `"enforced"` tier keeps every
+*  write gate on the historical three checks; only pass `"strict"` from
+*  report-only surfaces. */
+function validateRecordObject(record, itemId, schema, tier = "enforced") {
+	const idValue = record[schema.primaryKey];
+	if (typeof idValue !== "string") return `'${schema.primaryKey}' must be a string, but is ${describeIdType(idValue)} — must equal the filename ('${itemId}'), or the record can't be opened`;
+	if (idValue !== itemId) return `'${schema.primaryKey}' is '${idValue}' but must equal the filename ('${itemId}'), or the record can't be opened`;
+	return firstRecordProblem(record, schema, tier);
+}
+//#endregion
 //#region src/collection/server/mutate.ts
 /** First problem with the submitted params, or null. Every declared param
 *  is checked by the shared record-field validator; keys the action never
@@ -2651,32 +2533,6 @@ async function handleGetOntology(deps) {
 		collections
 	});
 }
-/** Publish this repository's `app.json` + shared schemas to its Firestore app.
-*
-*  Named as a whole-app action because it IS one: publish takes the repository
-*  as its unit (one roster, one public config, every shared collection), so it
-*  carries no `slug` and refusing one is not a limitation to work around.
-*
-*  The reply is prose rather than a status code on purpose. This is the one
-*  operation in the collection surface that changes what every member sees the
-*  moment it lands, and the two things the caller has to relay — what will
-*  break, and that `confirm` is how it proceeds anyway — are sentences, not
-*  fields. */
-async function handlePublishApp(deps, confirm) {
-	const result = await publishApp({
-		...deps,
-		confirm
-	});
-	if (!result.ok) {
-		const bullets = result.problems.map((problem) => `- ${problem}`).join("\n");
-		return `${result.partial ? "publish FAILED PART-WAY — some documents are already live:" : "publish refused — nothing was written:"}\n${bullets}`;
-	}
-	const dirtyNote = result.dirty ? " (WORKING TREE DIRTY — the commit does not describe what was published)" : "";
-	const stamp = result.commit ? `commit ${result.commit.slice(0, 12)}${dirtyNote}` : "no commit (not a git repository, or no HEAD)";
-	const brokenCount = result.recordIssuesCapped ? `at least ${result.recordIssues}` : `${result.recordIssues}`;
-	const forced = result.recordIssues > 0 ? ` Published over ${brokenCount} record(s) that do not satisfy the new schema — repair them now; members are reading them.` : "";
-	return `${result.created ? "Created" : "Updated"} app '${result.aid}' and published ${result.cids.length} collection(s): ${result.cids.join(", ")}. Signed ${stamp}. The previous app document is kept in \`previousPublished\` for rollback.${forced}`;
-}
 /** Return the collection-authoring reference (`collection-skills.md`),
 *  rendered by `renderSchemaDocs` — the full doc overflows the agent's
 *  per-result limit, so the default reply is the core guide + a table of
@@ -2785,7 +2641,7 @@ async function handlePutSchema(slug, schemaArg, deps) {
 		written: true
 	});
 }
-var MANAGE_COLLECTION_PROMPT = "Use `manageCollection` instead of raw Read/Write/Edit when working with a collection's records OR its schema (raw file I/O stays available as the escape hatch). Before authoring or changing a collection's `schema.json`, call `schemaDocs` to load the field/DSL reference — the default reply is the core authoring guide plus a table of contents; fetch advanced sections (actions, bells, calendar/kanban views, dataSource, storage) by passing their heading as `topic` rather than dumping `topic: \"all\"`. Then read with `getSchema` and write with `putSchema` — `putSchema` validates the whole schema before writing and returns actionable errors instead of silently failing discovery's validation. `getItems` is the only way to see computed values — `derived` fields (e.g. a portfolio's value), `toggle` projections, and `embed` records are host-computed and never present in the stored JSON files. On large collections pass `ids` and/or `fields` to keep the result small. For a question that spans collections (\"which clients have unpaid invoices?\"), start with `getOntology`: it lists every collection with its primaryKey, record count, and outbound `ref`/`embed` relations, so you know which collections to join before reading any records. `putItems` validates every row against the schema before writing (required fields, enum values, primaryKey = record id) and returns `{ written, rejected }`; fix each rejected row using its `problem` text and retry just those rows. Never include computed fields in a row you write. To update a few fields of an existing record, use `mode: \"merge\"` with a partial row ({ id, <changed fields> }) — the default upsert replaces the WHOLE record, so a partial upsert would silently erase every optional field it omits. `deleteItems` removes records by id and returns `{ deleted, rejected }`; an id that doesn't exist comes back rejected rather than counted as deleted, so check `rejected` before reporting a deletion as done. `publishApp` publishes the whole repository — its `app.json` (member roster, public read/submit configuration) and every shared collection's schema — to the app's Firestore. It is the ONE operation here that changes what every member sees the moment it runs, and it cannot be undone by reverting a commit: publishing again is the only undo (the previous app document is kept as `previousPublished`). Call it when the user asks to publish, invite, or open an app; never as a follow-up to an edit the user did not ask you to ship. Its refusals are the product, not an obstacle — relay them verbatim, and do not work around one by rewriting `app.json` until the user has said what they actually want. If it reports live records the new schemas would break, show the user that list and ask before re-running with `confirm`. Answer aggregation questions (counts, sums, averages, group-bys) with `queryItems` on ANY collection — on a dataSource (CSV) collection it scans the whole file (getItems is row-capped, so aggregates computed from its output can be silently wrong on large files); on a file-backed collection it aggregates the enriched records, so computed fields (derived/rollup/toggle) are queryable columns.";
+var MANAGE_COLLECTION_PROMPT = "Use `manageCollection` instead of raw Read/Write/Edit when working with a collection's records OR its schema (raw file I/O stays available as the escape hatch). Before authoring or changing a collection's `schema.json`, call `schemaDocs` to load the field/DSL reference — the default reply is the core authoring guide plus a table of contents; fetch advanced sections (actions, bells, calendar/kanban views, dataSource, storage) by passing their heading as `topic` rather than dumping `topic: \"all\"`. Then read with `getSchema` and write with `putSchema` — `putSchema` validates the whole schema before writing and returns actionable errors instead of silently failing discovery's validation. `getItems` is the only way to see computed values — `derived` fields (e.g. a portfolio's value), `toggle` projections, and `embed` records are host-computed and never present in the stored JSON files. On large collections pass `ids` and/or `fields` to keep the result small. For a question that spans collections (\"which clients have unpaid invoices?\"), start with `getOntology`: it lists every collection with its primaryKey, record count, and outbound `ref`/`embed` relations, so you know which collections to join before reading any records. `putItems` validates every row against the schema before writing (required fields, enum values, primaryKey = record id) and returns `{ written, rejected }`; fix each rejected row using its `problem` text and retry just those rows. Never include computed fields in a row you write. To update a few fields of an existing record, use `mode: \"merge\"` with a partial row ({ id, <changed fields> }) — the default upsert replaces the WHOLE record, so a partial upsert would silently erase every optional field it omits. `deleteItems` removes records by id and returns `{ deleted, rejected }`; an id that doesn't exist comes back rejected rather than counted as deleted, so check `rejected` before reporting a deletion as done. Answer aggregation questions (counts, sums, averages, group-bys) with `queryItems` on ANY collection — on a dataSource (CSV) collection it scans the whole file (getItems is row-capped, so aggregates computed from its output can be silently wrong on large files); on a file-backed collection it aggregates the enriched records, so computed fields (derived/rollup/toggle) are queryable columns.";
 /** Validate getItems' optional `ids`/`fields` args, then delegate. */
 async function dispatchGetItems(collection, args, deps) {
 	const ids = optionalStringArray(args.ids, "ids");
@@ -2830,19 +2686,18 @@ async function dispatchManageCollection(deps, args) {
 	const action = typeof args.action === "string" ? args.action : "";
 	if (action === "schemaDocs") return handleSchemaDocs(deps, typeof args.topic === "string" ? args.topic : void 0);
 	if (action === "getOntology") return handleGetOntology(deps);
-	if (action === "publishApp") return handlePublishApp(deps, args.confirm === true);
 	const slug = typeof args.slug === "string" ? args.slug.trim() : "";
 	if (!slug) return "manageCollection: `slug` is required (the collection's slug).";
 	if (action === "getSchema") return handleGetSchema(slug, deps);
 	if (action === "putSchema") return handlePutSchema(slug, args.schema, deps);
-	if (!RECORD_ACTIONS.has(action)) return "manageCollection: `action` must be \"getItems\", \"putItems\", \"deleteItems\", \"queryItems\", \"getOntology\", \"schemaDocs\", \"getSchema\", \"putSchema\", or \"publishApp\".";
+	if (!RECORD_ACTIONS.has(action)) return "manageCollection: `action` must be \"getItems\", \"putItems\", \"deleteItems\", \"queryItems\", \"getOntology\", \"schemaDocs\", \"getSchema\", or \"putSchema\".";
 	const collection = await loadCollection(slug, deps);
 	if (!collection) return unknownCollection(slug);
 	return dispatchRecordAction(action, collection, args, deps);
 }
 var MANAGE_COLLECTION_DEFINITION = {
 	name: "manageCollection",
-	description: "Read and write a schema-driven collection through the host — both its records and its structure. getItems returns records WITH computed values (derived formulas, toggles, embeds) the stored JSON files don't contain; putItems validates each row against the schema before writing; deleteItems removes records by id. getOntology maps the whole workspace: every collection with its record count and outbound ref/embed relations — call it first for cross-collection questions. schemaDocs returns the collection-authoring reference — the core guide plus a table of contents by default; pass `topic` for a specific section. getSchema/putSchema read and validate-then-write the collection's schema.json. publishApp publishes the repository's app.json + shared schemas to Firestore, where every member sees them immediately -- it refuses declarations that would be silently permissive or silently deny everyone, and refuses to publish over records the new schemas would break unless `confirm` is set. Prefer it over raw file I/O on collections.",
+	description: "Read and write a schema-driven collection through the host — both its records and its structure. getItems returns records WITH computed values (derived formulas, toggles, embeds) the stored JSON files don't contain; putItems validates each row against the schema before writing; deleteItems removes records by id. getOntology maps the whole workspace: every collection with its record count and outbound ref/embed relations — call it first for cross-collection questions. schemaDocs returns the collection-authoring reference — the core guide plus a table of contents by default; pass `topic` for a specific section. getSchema/putSchema read and validate-then-write the collection's schema.json. Prefer it over raw file I/O on collections.",
 	inputSchema: {
 		type: "object",
 		properties: {
@@ -2856,8 +2711,7 @@ var MANAGE_COLLECTION_DEFINITION = {
 					"getOntology",
 					"schemaDocs",
 					"getSchema",
-					"putSchema",
-					"publishApp"
+					"putSchema"
 				],
 				description: "What to do."
 			},
@@ -2893,10 +2747,6 @@ var MANAGE_COLLECTION_DEFINITION = {
 				type: "object",
 				description: "putSchema: the full collection schema object (same shape as schema.json — title, icon, dataPath, primaryKey, fields, …). Call getSchema first for the current one, and schemaDocs for the field DSL."
 			},
-			confirm: {
-				type: "boolean",
-				description: "publishApp: publish even though existing records fail the schemas being published. Omit it first — the refusal lists what would break, and that list is the thing to show the user before asking."
-			},
 			topic: {
 				type: "string",
 				description: "schemaDocs: fetch one section of the reference by heading (case-insensitive substring — e.g. \"field types\", \"kanban\", \"calendar\", \"dataSource\"). Omit for the core authoring guide plus a table of contents of every section; \"all\" returns the full document (large — it can exceed your tool-result limit)."
@@ -2918,6 +2768,6 @@ function makeManageCollectionTool(deps = {}) {
 	};
 }
 //#endregion
-export { readSkillTemplate as A, APPS_COLLECTION as B, enrichItems as C, promptPathsFor as D, buildCollectionActionSeedPrompt as E, validateRecordObject as F, APP_ROLES as G, appConfigPath as H, compileRecordZ as I, AuthoredAppZ as K, recordFieldProblem as L, MAX_RECORD_ISSUES as M, STORE_UNREADABLE as N, readCustomViewHtml as O, validateCollectionRecords as P, bindsSubmitterIdentity as R, runCollectionQuery as S, buildActionSeedPrompt as T, appSchemasPath as U, PUBLIC_CONFIG_DOC as V, projectApp as W, computeCollectionIcon as _, deleteCollection as a, applyMutateAction as b, computeSuccessor as c, isTriggerDue as d, maybeSpawnSuccessor as f, ONE_SECOND_MS as g, successorId as h, deleteCustomView as i, publishApp as j, readCustomViewI18n as k, daysInMonth as l, resolveEvery as m, MAX_UNSELECTIVE_ITEMS as n, deleteCollectionRefusalMessage as o, parseCivil as p, parseAuthoredApp as q, makeManageCollectionTool as r, advanceTriggerDate as s, MAX_SCHEMA_ISSUES as t, formatCivil as u, buildWorkspaceOntology as v, runQueryOverRows as w, firstMutateParamProblem as x, schemaRelations as y, publishProblems as z };
+export { parseAuthoredApp as $, runQueryOverRows as A, APP_SLUGS_COLLECTION as B, STORE_UNREADABLE as C, recordFieldProblem as D, compileRecordZ as E, readCustomViewI18n as F, appStagingPath as G, appConfigPath as H, readSkillTemplate as I, projectPublish as J, projectApp as K, bindsSubmitterIdentity as L, buildCollectionActionSeedPrompt as M, promptPathsFor as N, runCollectionQuery as O, readCustomViewHtml as P, AuthoredAppZ as Q, publishProblems as R, MAX_RECORD_ISSUES as S, validateRecordObject as T, appSchemasPath as U, PUBLIC_CONFIG_DOC as V, appSlugDoc as W, stagedRuleConfig as X, promoteSchema as Y, APP_ROLES as Z, computeCollectionIcon as _, deleteCollection as a, applyMutateAction as b, computeSuccessor as c, isTriggerDue as d, maybeSpawnSuccessor as f, ONE_SECOND_MS as g, successorId as h, deleteCustomView as i, buildActionSeedPrompt as j, enrichItems as k, daysInMonth as l, resolveEvery as m, MAX_UNSELECTIVE_ITEMS as n, deleteCollectionRefusalMessage as o, parseCivil as p, projectDeploy as q, makeManageCollectionTool as r, advanceTriggerDate as s, MAX_SCHEMA_ISSUES as t, formatCivil as u, buildWorkspaceOntology as v, validateCollectionRecords as w, firstMutateParamProblem as x, schemaRelations as y, APPS_COLLECTION as z };
 
-//# sourceMappingURL=server-B48Jyxcj.js.map
+//# sourceMappingURL=server-zcM1ViCE.js.map