@mulmoclaude/core 0.23.1 → 0.24.0

package/dist/{server-Jaogu3Ky.cjs → server-CkysfLh4.cjs}

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
-const require_promptSafety = require("./promptSafety-DRd15gQ6.cjs");
+const require_promptSafety = require("./promptSafety-DI_1Rvhk.cjs");
 const require_collection_paths = require("./collection/paths.cjs");
 const require_skill_bridge_index = require("./skill-bridge/index.cjs");
 let node_path = require("node:path");
@@ -1505,6 +1505,32 @@ var WhenZ = zod.z.object({
 	field: zod.z.string().trim().min(1),
 	in: zod.z.array(zod.z.string().trim().min(1)).min(1)
 });
+var ValueRefZ = zod.z.object({
+	record: zod.z.string().trim().min(1).optional(),
+	field: zod.z.string().trim().min(1)
+});
+var WhereCondZ = zod.z.object({
+	field: zod.z.string().trim().min(1),
+	op: zod.z.enum([
+		"eq",
+		"ne",
+		"in",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"contains"
+	]),
+	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+	valueFrom: ValueRefZ.optional()
+}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
+	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
+	path: ["value"]
+}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
+	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
+	path: ["value"]
+});
+var WhereZ = zod.z.array(WhereCondZ);
 var fieldBase = {
 	label: zod.z.string().min(1),
 	primary: zod.z.boolean().optional(),
@@ -1715,6 +1741,30 @@ var ToggleFieldZ = zod.z.object({
 	onValue: zod.z.string().trim().min(1),
 	offValue: zod.z.string().trim().min(1)
 });
+/** A computed boolean: the record matched against a `where` predicate
+*  (the same AND-of-conditions shape `dynamicIcon` uses; evaluated by
+*  `./where`'s `matchesWhere`). Generic state summaries — isDone,
+*  isPassed, isQualified — become declared fields, so every
+*  field-driven mechanism (table cells, detail view, completion via
+*  `completionField`) picks them up without special cases. Never
+*  stored; computed by `deriveAll` on both server and client in the
+*  same saturation loop as `derived`, so a flag may read derived /
+*  rollup values — and other flags (`matchesWhere` stringifies, so
+*  `eq "true"` composes). Deliberately a STRUCTURED field, not formula
+*  syntax — the derived evaluator's no-string-literals boundary stays
+*  untouched (same reasoning as `rollup`). Cross-record
+*  `valueFrom.record` is rejected here: per-record evaluation has no
+*  `recordsById`, so it could only ever silently never-match.
+*  `where` condition fields are validated to exist by a schema-level
+*  refine below (a field can't see its siblings). */
+var FlagFieldZ = zod.z.object({
+	type: zod.z.literal("flag"),
+	...fieldBase,
+	where: WhereZ.min(1)
+}).refine((spec) => spec.where.every((cond) => cond.valueFrom?.record === void 0), {
+	message: "a flag's `where` cannot use `valueFrom.record` (cross-record references are unresolvable in per-record evaluation); use a literal `value` or a same-record `valueFrom` (field-to-field)",
+	path: ["where"]
+});
 var FieldSpecZ = zod.z.discriminatedUnion("type", [
 	ScalarFieldZ,
 	RefFieldZ,
@@ -1725,7 +1775,8 @@ var FieldSpecZ = zod.z.discriminatedUnion("type", [
 	EmbedFieldZ,
 	BacklinksFieldZ,
 	RollupFieldZ,
-	ToggleFieldZ
+	ToggleFieldZ,
+	FlagFieldZ
 ]);
 var actionBase = {
 	id: zod.z.string().trim().min(1),
@@ -1874,32 +1925,6 @@ var AgentIngestZ = zod.z.object({
 *  discovered from `<workspace>/feeds/` are REQUIRED to carry it (gated by
 *  `acceptParsedSchema`). */
 var IngestZ = zod.z.discriminatedUnion("kind", [DeclarativeIngestZ, AgentIngestZ]);
-var ValueRefZ = zod.z.object({
-	record: zod.z.string().trim().min(1).optional(),
-	field: zod.z.string().trim().min(1)
-});
-var WhereCondZ = zod.z.object({
-	field: zod.z.string().trim().min(1),
-	op: zod.z.enum([
-		"eq",
-		"ne",
-		"in",
-		"gt",
-		"gte",
-		"lt",
-		"lte",
-		"contains"
-	]),
-	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
-	valueFrom: ValueRefZ.optional()
-}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
-	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
-	path: ["value"]
-}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
-	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
-	path: ["value"]
-});
-var WhereZ = zod.z.array(WhereCondZ);
 var DynamicIconSourceZ = zod.z.object({
 	collection: zod.z.string().trim().min(1),
 	from: zod.z.enum([
@@ -1994,12 +2019,12 @@ function fieldDrivenFromFieldCarried(schema) {
 *  workspace-relative and containment-checked exactly like `dataPath`. The
 *  row-id column is the schema's existing `primaryKey` — there is
 *  deliberately no second key concept here.
-*  See plans/feat-collection-csv-duckdb-source.md. */
+*  See plans/done/feat-collection-csv-duckdb-source.md. */
 var DataSourceZ = zod.z.object({
 	type: zod.z.literal("csv"),
 	path: zod.z.string().min(1)
 });
-var CollectionSchemaZ = zod.z.object({
+var BareCollectionSchemaZ = zod.z.object({
 	title: zod.z.string().min(1),
 	icon: zod.z.string().min(1),
 	dataPath: zod.z.string().min(1).optional(),
@@ -2059,8 +2084,11 @@ var CollectionSchemaZ = zod.z.object({
 }).refine((schema) => collectCurrencyFieldRefs(schema.fields).every((name) => CODE_FIELD_TYPES.has(schema.fields[name]?.type ?? "")), {
 	message: "a money field's `currencyField` must name a top-level `string`, `text`, or `enum` field that holds the currency code",
 	path: ["fields"]
-}).refine((schema) => schema.completionField === void 0 === (schema.completionDoneValues === void 0), {
-	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted)",
+}).refine((schema) => {
+	if (schema.completionField !== void 0 && schema.fields[schema.completionField]?.type === "flag") return schema.completionDoneValues === void 0;
+	return schema.completionField === void 0 === (schema.completionDoneValues === void 0);
+}, {
+	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted) — unless `completionField` names a `flag` field, in which case `completionDoneValues` must be omitted (done ⇔ the flag matches)",
 	path: ["completionField"]
 }).refine((schema) => schema.completionField === void 0 || schema.fields[schema.completionField] !== void 0, {
 	message: "schema `completionField` must name a top-level field declared in `fields`",
@@ -2071,6 +2099,22 @@ var CollectionSchemaZ = zod.z.object({
 }).refine((schema) => Object.values(schema.fields).every((field) => field.when === void 0 || schema.fields[field.when.field] !== void 0), {
 	message: "a field's `when.field` must name a top-level field declared in `fields`",
 	path: ["fields"]
+}).refine((schema) => Object.values(schema.fields).every((field) => field.type !== "flag" || field.where.every((cond) => schema.fields[cond.field] !== void 0 && (cond.valueFrom === void 0 || schema.fields[cond.valueFrom.field] !== void 0))), {
+	message: "a flag field's `where` conditions must name top-level fields declared in `fields` (both `field` and a same-record `valueFrom.field`)",
+	path: ["fields"]
+}).refine((schema) => {
+	const spec = schema.completionField === void 0 ? void 0 : schema.fields[schema.completionField];
+	if (spec?.type !== "flag") return true;
+	return spec.where.every((cond) => [cond.field, ...cond.valueFrom ? [cond.valueFrom.field] : []].every((name) => {
+		const target = schema.fields[name];
+		return target !== void 0 && !require_promptSafety.COMPUTED_TYPES.has(target.type);
+	}));
+}, {
+	message: "a `flag` named by `completionField` may only reference STORED fields in its `where` — completion is evaluated against the raw record (before deriveAll), where computed values (derived/rollup/toggle/flag/embed/backlinks) are absent",
+	path: ["completionField"]
+}).refine((schema) => schema.spawn === void 0 || schema.spawn.when !== void 0 || schema.fields[schema.completionField ?? ""]?.type !== "flag", {
+	message: "a schema whose `completionField` names a `flag` field must declare an explicit `spawn.when` (the spawn-inert check cannot statically evaluate a flag's `where`)",
+	path: ["spawn"]
 }).refine((schema) => Object.values(schema.fields).every((field) => {
 	if (field.type !== "embed" || field.idField === void 0) return true;
 	const target = schema.fields[field.idField];
@@ -2145,6 +2189,46 @@ var CollectionSchemaZ = zod.z.object({
 	message: "schema `views` must have unique `id`s",
 	path: ["views"]
 });
+var PROTOTYPE_KEYS = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+/** The first own prototype-sensitive key of `value`, or null. */
+function ownPrototypeKey(value) {
+	if (value === null || typeof value !== "object") return null;
+	for (const key of PROTOTYPE_KEYS) if (Object.hasOwn(value, key)) return key;
+	return null;
+}
+/** Dotted path of the first prototype-sensitive field name in the raw
+*  schema input — top-level `fields`, each table field's `of`, and each
+*  action's `params` (the three records that DEFINE names) — or null. */
+function prototypeFieldKeyPath(input) {
+	if (input === null || typeof input !== "object") return null;
+	const schema = input;
+	const bad = ownPrototypeKey(schema.fields);
+	if (bad !== null) return `fields.${bad}`;
+	for (const [key, spec] of Object.entries(schema.fields ?? {})) {
+		const badSub = ownPrototypeKey(spec?.of);
+		if (badSub !== null) return `fields.${key}.of.${badSub}`;
+	}
+	for (const [listName, list] of [["actions", schema.actions], ["collectionActions", schema.collectionActions]]) for (const action of Array.isArray(list) ? list : []) {
+		const badParam = ownPrototypeKey(action?.params);
+		if (badParam !== null) return `${listName}.params.${badParam}`;
+	}
+	return null;
+}
+var CollectionSchemaZ = zod.z.preprocess((input, ctx) => {
+	const bad = prototypeFieldKeyPath(input);
+	if (bad !== null) {
+		ctx.addIssue({
+			code: "custom",
+			message: `'${bad}': field names must not be prototype-sensitive keys (\`__proto__\`, \`constructor\`, \`prototype\`)`
+		});
+		return zod.z.NEVER;
+	}
+	return input;
+}, BareCollectionSchemaZ);
 //#endregion
 //#region src/collection/server/discovery.ts
 function applyFeedSchemaDefaults(parsed, slug) {
@@ -2705,17 +2789,15 @@ function successorId(sourceId, next) {
 }
 /** True iff `item` satisfies the spawn predicate. With an explicit
 *  `when`, matches `String(item[when.field]) ∈ when.in`. Without one,
-*  defaults to the completion-done condition. Self-contained (no import
-*  from notifications.ts) to keep the module graph acyclic. */
+*  defaults to the completion-done condition — the shared, flag-aware
+*  `itemIsDone` (core/completion; downhill import, so the module graph
+*  stays acyclic). */
 function matchesWhen(when, schema, item) {
 	if (when) {
 		const raw = item[when.field];
 		return raw !== void 0 && raw !== null && when.in.includes(String(raw));
 	}
-	const { completionField, completionDoneValues } = schema;
-	if (!completionField || !completionDoneValues) return false;
-	const raw = item[completionField];
-	return raw !== void 0 && raw !== null && completionDoneValues.includes(String(raw));
+	return require_promptSafety.itemIsDone(schema, item);
 }
 /** Resolve the literal `every` that applies to `sourceItem`. Literal-arm
 *  `spawn.every` passes through unchanged. Field-driven `spawn.every` reads
@@ -3965,4 +4047,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=server-Jaogu3Ky.cjs.map
+//# sourceMappingURL=server-CkysfLh4.cjs.map