@mulmoclaude/core 3.11.0 → 3.12.0

package/dist/collection/registry/server/index.cjs

@@ -5,7 +5,7 @@ const require_root = require("../../../root-rPH6FGDT.cjs");
 const require_relPath = require("../../../relPath-CTAjGdCL.cjs");
 const require_utils_fetch = require("../../../utils/fetch.cjs");
 const require_discovery = require("../../../discovery-BsXiDZBR.cjs");
-const require_server = require("../../../server-X_magqUa.cjs");
+const require_server = require("../../../server-BIKy55wo.cjs");
 const require_templatePath = require("../../../templatePath-27vUZowm.cjs");
 const require_skill_bridge_index = require("../../../skill-bridge/index.cjs");
 const require_types = require("../../../types-CNqkLT4M.cjs");

package/dist/collection/registry/server/index.js

@@ -3,7 +3,7 @@ import { n as writeFileAtomic } from "../../../root-BMroU_mB.js";
 import { n as toPosixRelPath } from "../../../relPath-DW8MC8VO.js";
 import { fetchWithTimeout } from "../../../utils/fetch.js";
 import { $ as collectionsRegistriesConfigPath, G as safeRecordId, ct as projectSkillsDir, mt as skillsStagingDir, nt as getWorkspaceRoot, ot as log, r as loadCollection, s as CollectionSchemaZ, t as acceptParsedSchema } from "../../../discovery-B9zdNkgW.js";
-import { g as ONE_SECOND_MS } from "../../../server-zcM1ViCE.js";
+import { g as ONE_SECOND_MS } from "../../../server-DkT40KgR.js";
 import { t as isSafeActionTemplatePath } from "../../../templatePath-k_WNbL_Q.js";
 import { claudeSkillDir, dataSkillDir, mirrorSkillWrite } from "../../../skill-bridge/index.js";
 import { n as parseRegistryIndex, r as isRecord, t as OFFICIAL_REGISTRY_NAME } from "../../../types-BKVZrtyc.js";

package/dist/collection/server/index.cjs

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_root = require("../../root-rPH6FGDT.cjs");
 const require_itemId = require("../../itemId-Dzrr3vs5.cjs");
 const require_discovery = require("../../discovery-BsXiDZBR.cjs");
-const require_server = require("../../server-X_magqUa.cjs");
+const require_server = require("../../server-BIKy55wo.cjs");
 const require_templatePath = require("../../templatePath-27vUZowm.cjs");
 exports.APPS_COLLECTION = require_server.APPS_COLLECTION;
 exports.APP_MANIFEST_FILE = require_discovery.APP_MANIFEST_FILE;
@@ -89,6 +89,7 @@ exports.projectDeploy = require_server.projectDeploy;
 exports.projectItemFields = require_discovery.projectItemFields;
 exports.projectPublish = require_server.projectPublish;
 exports.promoteSchema = require_server.promoteSchema;
+exports.promotedRoleProblems = require_server.promotedRoleProblems;
 exports.promptPathsFor = require_server.promptPathsFor;
 exports.publishCollectionChange = require_discovery.publishCollectionChange;
 exports.publishProblems = require_server.publishProblems;

package/dist/collection/server/index.d.ts

@@ -4,7 +4,7 @@ export { sharedItemsPath } from './firestoreStore';
 export { loadAppManifest, parseAppManifest, appManifestReason, APP_MANIFEST_FILE, type AppManifest, type AppManifestResult } from './appManifest';
 export { AuthoredAppZ, parseAuthoredApp, APP_ROLES, type AuthoredApp, type AuthoredCollectionConfig, type AuthoredMail, type AuthoredSubmit, } from './publishManifest';
 export { projectApp, projectDeploy, projectPublish, stagedRuleConfig, promoteSchema, appStagingPath, APP_SLUGS_COLLECTION, appSlugDoc, type AppSlugDoc, type DeployedApp, type PublishedFace, APPS_COLLECTION, PUBLIC_CONFIG_DOC, appConfigPath, appSchemasPath, type PublishStamp, type PublishedApp, type PublishedConfigDoc, type PublishedSchemaDoc, type StagedSchemaDoc, } from './publishProject';
-export { publishProblems, bindsSubmitterIdentity, type PublishableCollection } from './publishChecks';
+export { publishProblems, promotedRoleProblems, bindsSubmitterIdentity, type PublishableCollection } from './publishChecks';
 export type { LoadedCollection } from './discoveredCollection';
 export * from './paths';
 export * from './templatePath';

package/dist/collection/server/index.js

@@ -1,6 +1,6 @@
 import { t as canonicalRoot } from "../../root-BMroU_mB.js";
 import { N as COMPUTED_TYPES } from "../../itemId-DfTm08jm.js";
 import { A as readItem, B as SCHEMA_FILE, C as CollectionQueryZ, D as generateItemId, E as deleteItem, F as loadAppManifest, G as safeRecordId, H as itemFilePath, I as parseAppManifest, J as isBackendUnavailable, K as safeSlugName, L as sharedItemsPath, M as writeItem, N as APP_MANIFEST_FILE, O as isRegularFile, P as appManifestReason, Q as collectionChangePayload, R as pageFromFullRead, S as compileJsonlQuery, T as MAX_QUERY_ROWS, U as resolveDataDir, V as isContainedInRoot, W as resolveTemplatePath, Y as COLLECTION_ROOT_REQUIRED, Z as collectionChangeKey, _ as dedupeByRecordId, a as toDetail, at as localCollectionKey, d as storeFor, dt as setFirestoreAccessor, et as configureCollectionHost, ft as setSharedCollectionsSupport, g as decodeCsvRecordId, h as csvRowToItem, i as resolvePrimaryField, j as resolveCreateItemId, k as listItems, l as collectionWritable, lt as publishCollectionChange, n as discoverCollections, nt as getWorkspaceRoot, o as toSummary, ot as log, p as MAX_CSV_ROWS, pt as sharedCollectionChangePayload, q as BackendUnavailableError, r as loadCollection, rt as hostSupportsSharedCollections, s as CollectionSchemaZ, st as peekWorkspaceRoot, t as acceptParsedSchema, tt as firestoreHandle, u as readOnlyRefusal, ut as setCollectionChangePublisher, v as encodeCsvRecordId, w as DEFAULT_QUERY_ROWS, x as compileCsvQuery, y as normalizeCsvValue, z as projectItemFields } from "../../discovery-B9zdNkgW.js";
-import { $ as parseAuthoredApp, A as runQueryOverRows, B as APP_SLUGS_COLLECTION, C as STORE_UNREADABLE, D as recordFieldProblem, E as compileRecordZ, F as readCustomViewI18n, G as appStagingPath, H as appConfigPath, I as readSkillTemplate, J as projectPublish, K as projectApp, L as bindsSubmitterIdentity, M as buildCollectionActionSeedPrompt, N as promptPathsFor, O as runCollectionQuery, P as readCustomViewHtml, Q as AuthoredAppZ, R as publishProblems, S as MAX_RECORD_ISSUES, T as validateRecordObject, U as appSchemasPath, V as PUBLIC_CONFIG_DOC, W as appSlugDoc, X as stagedRuleConfig, Y as promoteSchema, Z as APP_ROLES, _ as computeCollectionIcon, a as deleteCollection, b as applyMutateAction, c as computeSuccessor, d as isTriggerDue, f as maybeSpawnSuccessor, h as successorId, i as deleteCustomView, j as buildActionSeedPrompt, k as enrichItems, l as daysInMonth, m as resolveEvery, n as MAX_UNSELECTIVE_ITEMS, o as deleteCollectionRefusalMessage, p as parseCivil, q as projectDeploy, r as makeManageCollectionTool, s as advanceTriggerDate, t as MAX_SCHEMA_ISSUES, u as formatCivil, v as buildWorkspaceOntology, w as validateCollectionRecords, x as firstMutateParamProblem, y as schemaRelations, z as APPS_COLLECTION } from "../../server-zcM1ViCE.js";
+import { $ as AuthoredAppZ, A as runQueryOverRows, B as APPS_COLLECTION, C as STORE_UNREADABLE, D as recordFieldProblem, E as compileRecordZ, F as readCustomViewI18n, G as appSlugDoc, H as PUBLIC_CONFIG_DOC, I as readSkillTemplate, J as projectDeploy, K as appStagingPath, L as bindsSubmitterIdentity, M as buildCollectionActionSeedPrompt, N as promptPathsFor, O as runCollectionQuery, P as readCustomViewHtml, Q as APP_ROLES, R as promotedRoleProblems, S as MAX_RECORD_ISSUES, T as validateRecordObject, U as appConfigPath, V as APP_SLUGS_COLLECTION, W as appSchemasPath, X as promoteSchema, Y as projectPublish, Z as stagedRuleConfig, _ as computeCollectionIcon, a as deleteCollection, b as applyMutateAction, c as computeSuccessor, d as isTriggerDue, et as parseAuthoredApp, f as maybeSpawnSuccessor, h as successorId, i as deleteCustomView, j as buildActionSeedPrompt, k as enrichItems, l as daysInMonth, m as resolveEvery, n as MAX_UNSELECTIVE_ITEMS, o as deleteCollectionRefusalMessage, p as parseCivil, q as projectApp, r as makeManageCollectionTool, s as advanceTriggerDate, t as MAX_SCHEMA_ISSUES, u as formatCivil, v as buildWorkspaceOntology, w as validateCollectionRecords, x as firstMutateParamProblem, y as schemaRelations, z as publishProblems } from "../../server-DkT40KgR.js";
 import { i as isSafeTemplatePath, n as isSafeCustomViewI18nPath, r as isSafeCustomViewPath, t as isSafeActionTemplatePath } from "../../templatePath-k_WNbL_Q.js";
-export { APPS_COLLECTION, APP_MANIFEST_FILE, APP_ROLES, APP_SLUGS_COLLECTION, AuthoredAppZ, BackendUnavailableError, COLLECTION_ROOT_REQUIRED, COMPUTED_TYPES, CollectionQueryZ, CollectionSchemaZ, DEFAULT_QUERY_ROWS, MAX_CSV_ROWS, MAX_QUERY_ROWS, MAX_RECORD_ISSUES, MAX_SCHEMA_ISSUES, MAX_UNSELECTIVE_ITEMS, PUBLIC_CONFIG_DOC, SCHEMA_FILE, STORE_UNREADABLE, acceptParsedSchema, advanceTriggerDate, appConfigPath, appManifestReason, appSchemasPath, appSlugDoc, appStagingPath, applyMutateAction, bindsSubmitterIdentity, buildActionSeedPrompt, buildCollectionActionSeedPrompt, buildWorkspaceOntology, canonicalRoot, collectionChangeKey, collectionChangePayload, collectionWritable, compileCsvQuery, compileJsonlQuery, compileRecordZ, computeCollectionIcon, computeSuccessor, configureCollectionHost, csvRowToItem, daysInMonth, decodeCsvRecordId, dedupeByRecordId, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, encodeCsvRecordId, enrichItems, firestoreHandle, firstMutateParamProblem, formatCivil, generateItemId, getWorkspaceRoot, hostSupportsSharedCollections, isBackendUnavailable, isContainedInRoot, isRegularFile, isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadAppManifest, loadCollection, localCollectionKey, log, makeManageCollectionTool, maybeSpawnSuccessor, normalizeCsvValue, pageFromFullRead, parseAppManifest, parseAuthoredApp, parseCivil, peekWorkspaceRoot, projectApp, projectDeploy, projectItemFields, projectPublish, promoteSchema, promptPathsFor, publishCollectionChange, publishProblems, readCustomViewHtml, readCustomViewI18n, readItem, readOnlyRefusal, readSkillTemplate, recordFieldProblem, resolveCreateItemId, resolveDataDir, resolveEvery, resolvePrimaryField, resolveTemplatePath, runCollectionQuery, runQueryOverRows, safeRecordId, safeSlugName, schemaRelations, setCollectionChangePublisher, setFirestoreAccessor, setSharedCollectionsSupport, sharedCollectionChangePayload, sharedItemsPath, stagedRuleConfig, storeFor, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };
+export { APPS_COLLECTION, APP_MANIFEST_FILE, APP_ROLES, APP_SLUGS_COLLECTION, AuthoredAppZ, BackendUnavailableError, COLLECTION_ROOT_REQUIRED, COMPUTED_TYPES, CollectionQueryZ, CollectionSchemaZ, DEFAULT_QUERY_ROWS, MAX_CSV_ROWS, MAX_QUERY_ROWS, MAX_RECORD_ISSUES, MAX_SCHEMA_ISSUES, MAX_UNSELECTIVE_ITEMS, PUBLIC_CONFIG_DOC, SCHEMA_FILE, STORE_UNREADABLE, acceptParsedSchema, advanceTriggerDate, appConfigPath, appManifestReason, appSchemasPath, appSlugDoc, appStagingPath, applyMutateAction, bindsSubmitterIdentity, buildActionSeedPrompt, buildCollectionActionSeedPrompt, buildWorkspaceOntology, canonicalRoot, collectionChangeKey, collectionChangePayload, collectionWritable, compileCsvQuery, compileJsonlQuery, compileRecordZ, computeCollectionIcon, computeSuccessor, configureCollectionHost, csvRowToItem, daysInMonth, decodeCsvRecordId, dedupeByRecordId, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, encodeCsvRecordId, enrichItems, firestoreHandle, firstMutateParamProblem, formatCivil, generateItemId, getWorkspaceRoot, hostSupportsSharedCollections, isBackendUnavailable, isContainedInRoot, isRegularFile, isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadAppManifest, loadCollection, localCollectionKey, log, makeManageCollectionTool, maybeSpawnSuccessor, normalizeCsvValue, pageFromFullRead, parseAppManifest, parseAuthoredApp, parseCivil, peekWorkspaceRoot, projectApp, projectDeploy, projectItemFields, projectPublish, promoteSchema, promotedRoleProblems, promptPathsFor, publishCollectionChange, publishProblems, readCustomViewHtml, readCustomViewI18n, readItem, readOnlyRefusal, readSkillTemplate, recordFieldProblem, resolveCreateItemId, resolveDataDir, resolveEvery, resolvePrimaryField, resolveTemplatePath, runCollectionQuery, runQueryOverRows, safeRecordId, safeSlugName, schemaRelations, setCollectionChangePublisher, setFirestoreAccessor, setSharedCollectionsSupport, sharedCollectionChangePayload, sharedItemsPath, stagedRuleConfig, storeFor, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };

package/dist/collection/server/publishChecks.d.ts

@@ -1,4 +1,5 @@
 import { AuthoredApp, AuthoredSubmit } from './publishManifest';
+import { StagedSchemaDoc } from './publishProject';
 /** What publish knows about a shared collection in this repository, as far as
  *  these checks are concerned: its cid and the schema key its records are
  *  identified by. The whole schema is deliberately not threaded in — these
@@ -27,3 +28,31 @@ export declare function bindsSubmitterIdentity(submit: AuthoredSubmit): boolean;
  *  All of them, every time. Publish is a manual step with a human waiting on
  *  it; stopping at the first problem turns one review into five. */
 export declare function publishProblems(app: AuthoredApp, collections: readonly PublishableCollection[], publisherEmail: string): string[];
+/** What publish will actually promote, checked as the PAIR it becomes.
+ *
+ *  `publishProblems` reads the manifest, where `members` and `collections` sit
+ *  side by side and agree. Publish does not write that pair. It writes the
+ *  roster from the manifest and the collection configuration from what DEPLOY
+ *  staged, so the app that lands is one half of each — and no check has ever
+ *  looked at that combination.
+ *
+ *  The sequence that gets through: deploy revision A with no `assigneeField`,
+ *  add the field AND the member in revision B, publish without redeploying.
+ *  Every manifest-level check passes on a declaration that is internally sound,
+ *  while what lands is A's field-less configuration beside B's roster — an
+ *  assignee with nothing to be compared against, refused every write, in an app
+ *  that keeps working for everybody else. That is the precise trap
+ *  `assigneeProblems` exists to prevent, reached by the one route it cannot
+ *  see.
+ *
+ *  Separate from `publishProblems` because it needs what deploy staged, which
+ *  is a Firestore read the host makes and this package does not. It is checked
+ *  against `stagedRuleConfig` — the same function the projection uses — rather
+ *  than against a re-derivation, so the value validated is the value written.
+ *
+ *  Only the staged half can be stale, so only that half is named and the fix is
+ *  "deploy again" rather than "fix the declaration". */
+export declare function promotedRoleProblems(app: AuthoredApp, staged: {
+    cid: string;
+    doc: StagedSchemaDoc;
+}[]): string[];

package/dist/collection/server/publishManifest.d.ts

@@ -1,7 +1,23 @@
 import { z } from 'zod';
-/** The four roles the deployed rules understand. `participant` is the layer
- *  that is NAMED but reads only its own rows — see `readerOf` vs `listedIn`. */
-export declare const APP_ROLES: readonly ["owner", "editor", "viewer", "participant"];
+/** The roles the deployed rules understand.
+ *
+ *  Two of them are row-scoped, in opposite directions, and the pair is what
+ *  the four-way split could not express:
+ *
+ *    `participant` — the layer that is NAMED but reads only its OWN rows (the
+ *    rows it submitted). See `readerOf` vs `listedIn`.
+ *
+ *    `assignee` — reads EVERY row and writes only the rows ASSIGNED to it. The
+ *    stylist who approves their own bookings and not a colleague's; the marker
+ *    who grades their own students. Which rows are theirs is
+ *    `collections[cid].assigneeField`, a field on the record holding the
+ *    member's address. Reads are deliberately unscoped: a stylist needs the
+ *    whole day's schedule, and scoping the read makes the app unusable.
+ *
+ *  The names are permanent. The deployed rules compare these strings directly
+ *  and they are written into `app.json` files people commit, so a rename is a
+ *  migration over published apps rather than an edit. */
+export declare const APP_ROLES: readonly ["owner", "editor", "viewer", "participant", "assignee"];
 /** The declarative mail queue, as the rules re-derive it: a transition of the
  *  status field, a recipient read off the RECORD, and a fixed template. */
 declare const MailZ: z.ZodObject<{
@@ -19,6 +35,7 @@ declare const CollectionConfigZ: z.ZodObject<{
     transitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     immutable: z.ZodOptional<z.ZodBoolean>;
     submitOnly: z.ZodOptional<z.ZodBoolean>;
+    assigneeField: z.ZodOptional<z.ZodString>;
     peerVisibility: z.ZodOptional<z.ZodEnum<{
         public: "public";
         hidden: "hidden";
@@ -63,7 +80,13 @@ declare const SubmitZ: z.ZodObject<{
     window: z.ZodOptional<z.ZodObject<{
         from: z.ZodOptional<z.ZodISODateTime>;
         until: z.ZodOptional<z.ZodISODateTime>;
+        fromField: z.ZodOptional<z.ZodObject<{
+            ref: z.ZodString;
+            collection: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
+    stampField: z.ZodOptional<z.ZodString>;
     selfUpdate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     selfTransitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     finalize: z.ZodOptional<z.ZodBoolean>;
@@ -92,12 +115,14 @@ export declare const AuthoredAppZ: z.ZodObject<{
         editor: "editor";
         viewer: "viewer";
         participant: "participant";
+        assignee: "assignee";
     }>>>;
     collections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         statusField: z.ZodOptional<z.ZodString>;
         transitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         immutable: z.ZodOptional<z.ZodBoolean>;
         submitOnly: z.ZodOptional<z.ZodBoolean>;
+        assigneeField: z.ZodOptional<z.ZodString>;
         peerVisibility: z.ZodOptional<z.ZodEnum<{
             public: "public";
             hidden: "hidden";
@@ -146,7 +171,13 @@ export declare const AuthoredAppZ: z.ZodObject<{
             window: z.ZodOptional<z.ZodObject<{
                 from: z.ZodOptional<z.ZodISODateTime>;
                 until: z.ZodOptional<z.ZodISODateTime>;
+                fromField: z.ZodOptional<z.ZodObject<{
+                    ref: z.ZodString;
+                    collection: z.ZodString;
+                    field: z.ZodString;
+                }, z.core.$strict>>;
             }, z.core.$strict>>;
+            stampField: z.ZodOptional<z.ZodString>;
             selfUpdate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
             selfTransitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
             finalize: z.ZodOptional<z.ZodBoolean>;

package/dist/collection-watchers/index.cjs

@@ -4,7 +4,7 @@ const require_itemId = require("../itemId-Dzrr3vs5.cjs");
 const require_promptSafety = require("../promptSafety-CWqYq-NS.cjs");
 require("../collection/index.cjs");
 const require_discovery = require("../discovery-BsXiDZBR.cjs");
-const require_server = require("../server-X_magqUa.cjs");
+const require_server = require("../server-BIKy55wo.cjs");
 const require_notifier = require("../notifier-DZJj0sOh.cjs");
 let node_fs_promises = require("node:fs/promises");
 //#region src/collection-watchers/config.ts

package/dist/collection-watchers/index.js

@@ -3,7 +3,7 @@ import { B as fieldText, x as isValidCollectionName } from "../itemId-DfTm08jm.j
 import { E as whenMatches, f as itemIsDone } from "../promptSafety-CSdyp7RF.js";
 import "../collection/index.js";
 import { H as itemFilePath, Q as collectionChangePayload, d as storeFor, lt as publishCollectionChange, n as discoverCollections, pt as sharedCollectionChangePayload, r as loadCollection, st as peekWorkspaceRoot, tt as firestoreHandle } from "../discovery-B9zdNkgW.js";
-import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-zcM1ViCE.js";
+import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-DkT40KgR.js";
 import { d as publish, m as updateForPlugin, n as clear, s as listAll } from "../notifier-DhnwR82U.js";
 import { access } from "node:fs/promises";
 //#region src/collection-watchers/config.ts

package/dist/feeds/server/index.cjs

@@ -5,7 +5,7 @@ const require_root = require("../../root-rPH6FGDT.cjs");
 const require_itemId = require("../../itemId-Dzrr3vs5.cjs");
 const require_project = require("../../project-C1ep9pvo.cjs");
 const require_discovery = require("../../discovery-BsXiDZBR.cjs");
-const require_server = require("../../server-X_magqUa.cjs");
+const require_server = require("../../server-BIKy55wo.cjs");
 const require_feeds_paths = require("../paths.cjs");
 const require_ingestTypes = require("../../ingestTypes-B4XfrUoq.cjs");
 const require_notifier = require("../../notifier-DZJj0sOh.cjs");

package/dist/feeds/server/index.js

@@ -3,7 +3,7 @@ import { t as canonicalRoot } from "../../root-BMroU_mB.js";
 import { F as INGEST_KINDS, P as FEED_SCHEDULES } from "../../itemId-DfTm08jm.js";
 import { t as mergeIntoExisting } from "../../project-B0j_Vf_Q.js";
 import { K as safeSlugName, U as resolveDataDir, _t as createHostSlot, d as storeFor, gt as createForwardingLogger, k as listItems, n as discoverCollections } from "../../discovery-B9zdNkgW.js";
-import { I as readSkillTemplate, M as buildCollectionActionSeedPrompt, N as promptPathsFor } from "../../server-zcM1ViCE.js";
+import { I as readSkillTemplate, M as buildCollectionActionSeedPrompt, N as promptPathsFor } from "../../server-DkT40KgR.js";
 import { FEEDS_DIR, feedDir, feedStatePath, feedsRoot, ingestStateDir, ingestStatePath } from "../paths.js";
 import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../../ingestTypes-B312BwXg.js";
 import { d as publish, n as clear } from "../../notifier-DhnwR82U.js";

package/dist/{server-X_magqUa.cjs → server-BIKy55wo.cjs}

@@ -21,13 +21,30 @@ var NameZ = zod.z.string().refine(require_itemId.isValidCollectionName, { messag
 *  the rules compare it to `request.auth.token.email` verbatim, so any
 *  narrowing here would refuse addresses Firebase itself accepts. */
 var EmailZ = zod.z.string().trim().min(3).includes("@");
-/** The four roles the deployed rules understand. `participant` is the layer
-*  that is NAMED but reads only its own rows — see `readerOf` vs `listedIn`. */
+/** The roles the deployed rules understand.
+*
+*  Two of them are row-scoped, in opposite directions, and the pair is what
+*  the four-way split could not express:
+*
+*    `participant` — the layer that is NAMED but reads only its OWN rows (the
+*    rows it submitted). See `readerOf` vs `listedIn`.
+*
+*    `assignee` — reads EVERY row and writes only the rows ASSIGNED to it. The
+*    stylist who approves their own bookings and not a colleague's; the marker
+*    who grades their own students. Which rows are theirs is
+*    `collections[cid].assigneeField`, a field on the record holding the
+*    member's address. Reads are deliberately unscoped: a stylist needs the
+*    whole day's schedule, and scoping the read makes the app unusable.
+*
+*  The names are permanent. The deployed rules compare these strings directly
+*  and they are written into `app.json` files people commit, so a rename is a
+*  migration over published apps rather than an edit. */
 var APP_ROLES = [
 	"owner",
 	"editor",
 	"viewer",
-	"participant"
+	"participant",
+	"assignee"
 ];
 var RoleZ = zod.z.enum(APP_ROLES);
 /** `{ email: { "*" | cid: role } }`. The `"*"` key is the app-wide role; a
@@ -53,6 +70,21 @@ var CollectionConfigZ = zod.z.object({
 	transitions: zod.z.record(zod.z.string().trim().min(1), zod.z.array(zod.z.string().trim().min(1))).optional(),
 	immutable: zod.z.boolean().optional(),
 	submitOnly: zod.z.boolean().optional(),
+	/** The field naming the member a row belongs to, for the `assignee` role.
+	*
+	*  Holds an ADDRESS, because that is the only thing the rules can compare
+	*  a member against (`request.auth.token.email`). A `ref` to a staff
+	*  collection stores the target's primary-key slug, not an address, so it
+	*  cannot be this field — declare a plain field beside the ref and let the
+	*  ref stay the thing the UI renders. The alternative, having the rules
+	*  `get()` the staff record to read an address off it, costs a document
+	*  access on every write and puts a second document between an
+	*  authorization decision and its answer.
+	*
+	*  Only meaningful with a member holding `assignee` on this cid; a
+	*  declaration with the role and no field is refused (`assigneeProblems`),
+	*  because that member would silently hold nothing. */
+	assigneeField: zod.z.string().trim().min(1).optional(),
 	peerVisibility: zod.z.enum(["public", "hidden"]).optional(),
 	revealGated: zod.z.boolean().optional(),
 	gatedFrom: NameZ.optional(),
@@ -71,9 +103,32 @@ var CollectionConfigZ = zod.z.object({
 *  the rules do not coerce strings, so an ISO string reaching Firestore is a
 *  type error that fails CLOSED (`inWindow` refuses every submission and the
 *  author sees "nobody can submit", not an error). */
+/** A window bound that lives on ANOTHER record, read at write time.
+*
+*  `window.from` is one absolute instant for the whole collection, which is
+*  enough for a survey and useless for anything recurring: "each class opens
+*  three days before it starts, at 08:00" is a bound PER RECORD. So the bound
+*  is not computed in the rules — they have no usable date arithmetic and
+*  `request.time` is UTC, which is the wrong answer for "08:00" — it is
+*  computed by whoever schedules the class, stored on the class record as
+*  epoch millis, and merely COMPARED here.
+*
+*  `ref` is the field on the record being written that names the target
+*  (`classId`); `collection` is the cid the target lives in, fixed in the
+*  declaration so that a path is never built out of a value a submitter wrote;
+*  `field` is the epoch-millis field on the target.
+*
+*  Not spelled `in` — that is an operator in the rules language, and
+*  `w.fromField.in` does not parse there. */
+var WindowRefZ = zod.z.object({
+	ref: zod.z.string().trim().min(1),
+	collection: NameZ,
+	field: zod.z.string().trim().min(1)
+}).strict();
 var WindowZ = zod.z.object({
 	from: zod.z.iso.datetime().optional(),
-	until: zod.z.iso.datetime().optional()
+	until: zod.z.iso.datetime().optional(),
+	fromField: WindowRefZ.optional()
 }).strict();
 var ValidateZ = zod.z.object({
 	required: zod.z.array(zod.z.string().trim().min(1)).optional(),
@@ -106,6 +161,19 @@ var SubmitZ = zod.z.object({
 	idField: zod.z.string().trim().min(1).optional(),
 	validate: ValidateZ.optional(),
 	window: WindowZ.optional(),
+	/** A field the rules PIN to the server clock on create: the record must
+	*  carry `request.time` in it, and may never change it afterwards.
+	*
+	*  What it buys is an order nobody can jump. A first-come app takes its
+	*  capacity from rank rather than from a count — the rules cannot count
+	*  documents, so "the first 8" can only ever be a reading of the rows —
+	*  and a rank is only as honest as the timestamp it sorts by. `idFrom`
+	*  stops a person holding two places; nothing else stops them writing
+	*  yesterday's date into the field that decides who got there first.
+	*
+	*  Binds EVERY create, the writer branch included, so a staff-entered row
+	*  cannot be back-dated into the queue either. */
+	stampField: zod.z.string().trim().min(1).optional(),
 	/** Per CURRENT STATUS, never a flat list: a flat list lets a customer move
 	*  an approved booking's `startAt` without anyone re-approving it. */
 	selfUpdate: zod.z.record(zod.z.string().trim().min(1), zod.z.array(zod.z.string().trim().min(1))).optional(),
@@ -226,7 +294,11 @@ function windowMillis(window) {
 	if (window.from !== void 0) out.fromMs = Date.parse(window.from);
 	if (window.until !== void 0) out.untilMs = Date.parse(window.until);
 	if (Object.values(out).some((value) => !Number.isFinite(value))) throw new Error(`publish: window bound is not a parseable timestamp (${JSON.stringify(window)})`);
-	return Object.keys(out).length > 0 ? out : void 0;
+	const projected = {
+		...out,
+		...window.fromField === void 0 ? {} : { fromField: window.fromField }
+	};
+	return Object.keys(projected).length > 0 ? projected : void 0;
 }
 /** One `public.submit[cid]`, with its window lowered. Everything else passes
 *  through: the rules read these keys by the names the author wrote. */
@@ -653,7 +725,8 @@ function unknownCidProblems(app, collections) {
 		["collections", Object.keys(app.collections ?? {})],
 		["public.read", app.public?.read ?? []],
 		["public.submit", Object.keys(app.public?.submit ?? {})],
-		["participantRead", app.participantRead ?? []]
+		["participantRead", app.participantRead ?? []],
+		["members", [...new Set(Object.values(app.members).flatMap((roles) => Object.keys(roles)))].filter((key) => key !== "*")]
 	].flatMap(([where, cids]) => cids.filter((cid) => !known.has(cid)).map((cid) => `${where} names '${cid}', which is not a shared collection in this repository. Shared collections here: ${known.size > 0 ? [...known].sort().join(", ") : "(none - a schema needs storage.type \"firestore\")"}.`));
 }
 /** Everything publish refuses, as lines the author can act on.
@@ -670,7 +743,10 @@ function publishProblems(app, collections, publisherEmail) {
 		...mailProblems(app),
 		...submitShapeProblems(app),
 		...coherenceProblems(app),
-		...primaryKeyProblems(app, collections)
+		...primaryKeyProblems(app, collections),
+		...assigneeProblems(app),
+		...stampProblems(app),
+		...windowRefProblems(app, collections)
 	];
 }
 /** A public submission must NOT be allowed to name its own primary key.
@@ -700,6 +776,99 @@ function primaryKeyProblems(app, collections) {
 		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.`];
 	});
 }
+/** `assignee` without the field that says which rows are theirs.
+*
+*  A FAIL-CLOSED trap of the worst kind, because it fails closed for one
+*  person and nobody else: the rules ask `collections[cid].assigneeField` for
+*  the field to compare, find nothing, and refuse every write that member
+*  makes. The app works for the owner who set it up, and the member it was set
+*  up for is told only "permission denied".
+*
+*  `'*': "assignee"` is refused outright rather than checked against every
+*  collection. The role means "the rows assigned to you", and what counts as
+*  assigned is per collection — an app-wide one would need the same field name
+*  to be right everywhere, and where it is missing it silently means "no
+*  access to this collection" rather than "no scoping here".
+*/
+function assigneeProblems(app) {
+	return Object.entries(app.members).flatMap(([email, roles]) => Object.entries(roles).flatMap(([cid, role]) => {
+		if (role !== "assignee") return [];
+		if (cid === "*") return [`members["${email}"] holds "assignee" under "*", and the role cannot be app-wide: which rows are yours is declared per collection (\`collections.<cid>.assigneeField\`). Name the collections instead — { "bookings": "assignee" }.`];
+		if (app.collections?.[cid]?.assigneeField !== void 0) return [];
+		return [`members["${email}"] holds "assignee" on '${cid}', but collections.${cid}.assigneeField does not say which field names the member a row belongs to. Add it (assigneeField: "<a field holding an address>"), or give a role that is not row-scoped. Without it the rules have nothing to compare and refuse every write that member makes, while the app keeps working for everybody else.`];
+	}));
+}
+/** A server-stamped field the submitter cannot write, or can rewrite later.
+*
+*  Both failures are silent in opposite directions. Left out of
+*  `createFields`, the rules refuse every submission (`hasOnly(createFields)`
+*  rejects the key the stamp check requires) — an app nobody can use. Left IN
+*  a `selfUpdate` list, the field the queue is ordered by becomes editable by
+*  the person standing in the queue. */
+function stampProblems(app) {
+	return Object.entries(app.public?.submit ?? {}).flatMap(([cid, submit]) => {
+		const stamp = submit.stampField;
+		if (stamp === void 0) return [];
+		const problems = [];
+		if (!submit.createFields.includes(stamp)) problems.push(`public.submit.${cid}.stampField names '${stamp}', which is not in createFields. The rules require the record to CARRY the server time in that field, and refuse any key outside createFields — so every submission is denied. Add it to createFields; the page fills it in, not the person.`);
+		for (const [status, fields] of Object.entries(submit.selfUpdate ?? {})) {
+			if (!fields.includes(stamp)) continue;
+			problems.push(`public.submit.${cid}.selfUpdate.${status} lets the submitter write '${stamp}', which is the field stampField pins to the server clock. Whatever that field orders — a first-come queue, an audit trail — could then be rewritten by the person it ranks. Remove it from selfUpdate.`);
+		}
+		return problems;
+	});
+}
+/** A per-record window bound pointing at a collection or a field the submitter
+*  never writes.
+*
+*  `fromField` makes the rules read another record, and every part of that
+*  read is fail-closed: an unknown collection, or a `ref` the submission does
+*  not carry, means the bound can never be satisfied and the form is shut for
+*  good. */
+function windowRefProblems(app, collections) {
+	const known = new Set(collections.map((collection) => collection.cid));
+	return Object.entries(app.public?.submit ?? {}).flatMap(([cid, submit]) => {
+		const ref = submit.window?.fromField;
+		if (ref === void 0) return [];
+		const problems = [];
+		if (!known.has(ref.collection)) problems.push(`public.submit.${cid}.window.fromField.collection names '${ref.collection}', which is not a shared collection in this repository. The rules read the opening time off a record there, so nothing can ever be submitted. Shared collections here: ${known.size > 0 ? [...known].sort().join(", ") : "(none)"}.`);
+		if (!submit.createFields.includes(ref.ref)) problems.push(`public.submit.${cid}.window.fromField.ref names '${ref.ref}', which is not in createFields. The rules take the target record's id from that field ON THE SUBMISSION — if the submitter never writes it, there is nothing to look up and every submission is refused.`);
+		return problems;
+	});
+}
+/** What publish will actually promote, checked as the PAIR it becomes.
+*
+*  `publishProblems` reads the manifest, where `members` and `collections` sit
+*  side by side and agree. Publish does not write that pair. It writes the
+*  roster from the manifest and the collection configuration from what DEPLOY
+*  staged, so the app that lands is one half of each — and no check has ever
+*  looked at that combination.
+*
+*  The sequence that gets through: deploy revision A with no `assigneeField`,
+*  add the field AND the member in revision B, publish without redeploying.
+*  Every manifest-level check passes on a declaration that is internally sound,
+*  while what lands is A's field-less configuration beside B's roster — an
+*  assignee with nothing to be compared against, refused every write, in an app
+*  that keeps working for everybody else. That is the precise trap
+*  `assigneeProblems` exists to prevent, reached by the one route it cannot
+*  see.
+*
+*  Separate from `publishProblems` because it needs what deploy staged, which
+*  is a Firestore read the host makes and this package does not. It is checked
+*  against `stagedRuleConfig` — the same function the projection uses — rather
+*  than against a re-derivation, so the value validated is the value written.
+*
+*  Only the staged half can be stale, so only that half is named and the fix is
+*  "deploy again" rather than "fix the declaration". */
+function promotedRoleProblems(app, staged) {
+	const promoted = stagedRuleConfig(staged).collections ?? {};
+	const stagedCids = new Set(staged.map((entry) => entry.cid));
+	return Object.entries(app.members).flatMap(([email, roles]) => Object.entries(roles).flatMap(([cid, role]) => {
+		if (role !== "assignee" || cid === "*" || !stagedCids.has(cid)) return [];
+		if (promoted[cid]?.assigneeField !== void 0) return [];
+		return [`members["${email}"] holds "assignee" on '${cid}', and the STAGED version of '${cid}' — the one publish promotes — carries no assigneeField, even if app.json declares one now. Publish writes the roster from app.json and the collection configuration from the deploy, so that member would land with nothing to be compared against: refused every write, while the app keeps working for everybody else. Run deploy again, so the version being published is the one the declaration describes.`];
+	}));
+}
 //#endregion
 //#region src/collection/server/skillAssets.ts
 /** Read a collection's custom-view HTML, path-safely. `viewFile` is a
@@ -3004,6 +3173,12 @@ Object.defineProperty(exports, "promoteSchema", {
 		return promoteSchema;
 	}
 });
+Object.defineProperty(exports, "promotedRoleProblems", {
+	enumerable: true,
+	get: function() {
+		return promotedRoleProblems;
+	}
+});
 Object.defineProperty(exports, "promptPathsFor", {
 	enumerable: true,
 	get: function() {
@@ -3089,4 +3264,4 @@ Object.defineProperty(exports, "validateRecordObject", {
 	}
 });
 
-//# sourceMappingURL=server-X_magqUa.cjs.map
+//# sourceMappingURL=server-BIKy55wo.cjs.map