@bobbykim/manguito-cms-cli 0.6.1 → 0.7.0

package/dist/{chunk-SW3T2M64.js → chunk-52I54C3X.js}

@@ -49,7 +49,7 @@ var init_esm_shims = __esm({
   }
 });
 
-// ../api/dist/chunk-JVP33FI2.mjs
+// ../api/dist/chunk-FXPKGPYF.mjs
 init_esm_shims();
 import crypto from "crypto";
 
@@ -1212,7 +1212,7 @@ Subquery.prototype.getSQL = function() {
   return new SQL([this]);
 };
 
-// ../api/dist/chunk-JVP33FI2.mjs
+// ../api/dist/chunk-FXPKGPYF.mjs
 function isColumnBacked(field) {
   const col = field.db_column;
   if (col === null) return false;
@@ -1220,7 +1220,7 @@ function isColumnBacked(field) {
   if (col.junction) return false;
   return true;
 }
-function buildFieldKeyMap(pairs, allLabels, droppedKeys) {
+function buildFieldKeyMap(pairs, allLabels, droppedColumns, droppedLabels) {
   const labelToColumn = /* @__PURE__ */ new Map();
   const columnToLabel = /* @__PURE__ */ new Map();
   for (const { label, column } of pairs) {
@@ -1228,7 +1228,7 @@ function buildFieldKeyMap(pairs, allLabels, droppedKeys) {
     columnToLabel.set(column, label);
   }
   for (const { label, ownColumn } of allLabels) {
-    if (ownColumn === label) continue;
+    if (ownColumn !== void 0) continue;
     const columnOwner = columnToLabel.get(label);
     if (columnOwner !== void 0 && columnOwner !== label) {
       throw new Error(
@@ -1237,23 +1237,33 @@ function buildFieldKeyMap(pairs, allLabels, droppedKeys) {
     }
   }
   for (const label of labelToColumn.keys()) {
-    if (droppedKeys.has(label)) labelToColumn.delete(label);
+    if (droppedLabels.has(label)) labelToColumn.delete(label);
   }
   for (const column of columnToLabel.keys()) {
-    if (droppedKeys.has(column)) columnToLabel.delete(column);
+    if (droppedColumns.has(column)) columnToLabel.delete(column);
   }
   const diverges = [...labelToColumn].some(([label, column]) => label !== column);
-  function remap(input, lookup) {
+  function remap(input, lookup, dropped, droppedIfUnmapped) {
     const out = {};
     for (const key of Object.keys(input)) {
-      if (droppedKeys.has(key)) continue;
-      out[lookup.get(key) ?? key] = input[key];
+      const mapped = lookup.get(key);
+      if (mapped !== void 0) {
+        out[mapped] = input[key];
+        continue;
+      }
+      if (dropped.has(key) || droppedIfUnmapped?.has(key)) continue;
+      out[key] = input[key];
     }
     return out;
   }
   return {
-    toStorage: (input) => remap(input, labelToColumn),
-    toLabels: (row) => remap(row, columnToLabel),
+    // toStorage reads LABEL-keyed input: a live label maps and writes
+    // regardless of either drop set; an unmapped key is refused if it is
+    // EITHER the tombstone's own name (droppedLabels) or a raw, unexposed
+    // column (droppedColumns) — see remap's comment.
+    // toLabels reads COLUMN-keyed input, so it consults only droppedColumns.
+    toStorage: (input) => remap(input, labelToColumn, droppedLabels, droppedColumns),
+    toLabels: (row) => remap(row, columnToLabel, droppedColumns),
     columnFor: (label) => labelToColumn.get(label),
     labelFor: (column) => columnToLabel.get(column),
     labels: [...labelToColumn.keys()],
@@ -1261,14 +1271,15 @@ function buildFieldKeyMap(pairs, allLabels, droppedKeys) {
   };
 }
 function createFieldKeyMap(fields) {
-  const droppedKeys = /* @__PURE__ */ new Set();
+  const droppedColumns = /* @__PURE__ */ new Set();
+  const droppedLabels = /* @__PURE__ */ new Set();
   const pairs = [];
   for (const f of fields) {
     if (!isColumnBacked(f)) continue;
     pairs.push({ label: f.name, column: f.db_column.column_name });
     if (f.removed === true) {
-      droppedKeys.add(f.name);
-      droppedKeys.add(f.db_column.column_name);
+      droppedLabels.add(f.name);
+      droppedColumns.add(f.db_column.column_name);
     }
   }
   return buildFieldKeyMap(
@@ -1279,30 +1290,33 @@ function createFieldKeyMap(fields) {
       // forbids present-and-undefined.
       ...isColumnBacked(f) && { ownColumn: f.db_column.column_name }
     })),
-    droppedKeys
+    droppedColumns,
+    droppedLabels
   );
 }
 function createFieldKeyMapFromProjection(projectionType, allFields) {
   const pairs = projectionType.fields.map((f) => ({ label: f.exposed_as, column: f.column_name }));
-  const projected = new Set(pairs.map((p) => p.label));
-  const dropped = /* @__PURE__ */ new Set();
+  const projectedColumns = new Set(pairs.map((p) => p.column));
+  const projectedLabels = new Set(pairs.map((p) => p.label));
+  const droppedColumns = /* @__PURE__ */ new Set();
+  const droppedLabels = /* @__PURE__ */ new Set();
   for (const f of allFields) {
     if (!isColumnBacked(f)) continue;
-    dropped.add(f.name);
-    dropped.add(f.db_column.column_name);
+    if (!projectedColumns.has(f.db_column.column_name)) droppedColumns.add(f.db_column.column_name);
+    if (!projectedLabels.has(f.name)) droppedLabels.add(f.name);
   }
-  for (const p of pairs) dropped.delete(p.column);
-  for (const label of projected) dropped.delete(label);
   return buildFieldKeyMap(
     pairs,
     allFields.map((f) => ({
       label: f.name,
-      // See buildFieldKeyMap's collision check: this is what lets it tell a
-      // version exposing a field's own column under a new label (fine) from a
-      // label that reuses another field's column (not fine).
+      // See buildFieldKeyMap's collision check: `ownColumn` marks every
+      // column-backed field so the check skips it entirely — only a
+      // paragraph/junction/programmatic label (no column of its own) can
+      // still collide.
       ...isColumnBacked(f) && { ownColumn: f.db_column.column_name }
     })),
-    dropped
+    droppedColumns,
+    droppedLabels
   );
 }
 function quoteIdent(name) {
@@ -1474,9 +1488,8 @@ function groupBy(items, key) {
   }
   return result;
 }
-function needsFkResolution(row, fkColumn, fieldName) {
-  if (fkColumn !== fieldName && !(fkColumn in row)) return false;
-  const current = row[fieldName];
+function needsFkResolution(row, fkColumn) {
+  const current = row[fkColumn];
   return !(typeof current === "object" && current !== null);
 }
 async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOnly = false) {
@@ -1493,15 +1506,11 @@ async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOn
       row[fieldName] = byParent[row["id"]] ?? [];
     }
   } else if (rel.type === "reference") {
-    const dropFk = rel.fk_column !== fieldName;
-    const pending = batch.filter((r) => needsFkResolution(r, rel.fk_column, fieldName));
+    const pending = batch.filter((r) => needsFkResolution(r, rel.fk_column));
     if (pending.length === 0) return;
     const fkValues = pending.map((r) => r[rel.fk_column]).filter(Boolean);
     if (fkValues.length === 0) {
-      for (const row of pending) {
-        row[fieldName] = null;
-        if (dropFk) delete row[rel.fk_column];
-      }
+      for (const row of pending) row[rel.fk_column] = null;
       return;
     }
     const unique = [...new Set(fkValues)];
@@ -1518,8 +1527,7 @@ async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOn
     }
     for (const row of pending) {
       const fkVal = row[rel.fk_column];
-      row[fieldName] = fkVal ? cache.get(`${rel.table}:${fkVal}`) ?? null : null;
-      if (dropFk) delete row[rel.fk_column];
+      row[rel.fk_column] = fkVal ? cache.get(`${rel.table}:${fkVal}`) ?? null : null;
     }
   } else if (rel.type === "junction") {
     const parentIds = batch.map((r) => r["id"]);
@@ -1547,15 +1555,11 @@ async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOn
       row[fieldName] = jEntries.map((jr) => cache.get(`${rel.table}:${jr[rel.right_column]}`)).filter(Boolean);
     }
   } else if (rel.type === "media") {
-    const dropFk = rel.fk_column !== fieldName;
-    const pending = batch.filter((r) => needsFkResolution(r, rel.fk_column, fieldName));
+    const pending = batch.filter((r) => needsFkResolution(r, rel.fk_column));
     if (pending.length === 0) return;
     const fkValues = pending.map((r) => r[rel.fk_column]).filter(Boolean);
     if (fkValues.length === 0) {
-      for (const row of pending) {
-        row[fieldName] = null;
-        if (dropFk) delete row[rel.fk_column];
-      }
+      for (const row of pending) row[rel.fk_column] = null;
       return;
     }
     const unique = [...new Set(fkValues)];
@@ -1569,8 +1573,7 @@ async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOn
     }
     for (const row of pending) {
       const fkVal = row[rel.fk_column];
-      row[fieldName] = fkVal ? cache.get(`media:${fkVal}`) ?? null : null;
-      if (dropFk) delete row[rel.fk_column];
+      row[rel.fk_column] = fkVal ? cache.get(`media:${fkVal}`) ?? null : null;
     }
   }
 }

package/dist/{handler-XZVDLKZ2-2TIH4GG7.js → handler-GED3I7Z2-HZAD77OI.js}

@@ -11,7 +11,7 @@ import {
   init_esm_shims,
   isColumnBacked,
   resolveRelationField
-} from "./chunk-SW3T2M64.js";
+} from "./chunk-52I54C3X.js";
 
 // ../../node_modules/.pnpm/@whatwg-node+fetch@0.10.13/node_modules/@whatwg-node/fetch/dist/shouldSkipPonyfill.js
 var require_shouldSkipPonyfill = __commonJS({
@@ -10786,10 +10786,10 @@ var require_parser = __commonJS({
   }
 });
 
-// ../api/dist/handler-XZVDLKZ2.mjs
+// ../api/dist/handler-GED3I7Z2.mjs
 init_esm_shims();
 
-// ../api/dist/chunk-XNXM4W4K.mjs
+// ../api/dist/chunk-4LLELFAZ.mjs
 init_esm_shims();
 
 // ../../node_modules/.pnpm/graphql-yoga@5.21.2_graphql@16.14.2/node_modules/graphql-yoga/esm/index.js
@@ -30122,7 +30122,7 @@ function createYoga(options) {
   });
 }
 
-// ../api/dist/chunk-XNXM4W4K.mjs
+// ../api/dist/chunk-4LLELFAZ.mjs
 var import_dataloader = __toESM(require_dataloader(), 1);
 
 // ../../node_modules/.pnpm/@escape.tech+graphql-armor@3.2.0_@envelop+core@5.5.1_@escape.tech+graphql-armor-types@0.7.0/node_modules/@escape.tech/graphql-armor/dist/graphql-armor.esm.js
@@ -30880,7 +30880,7 @@ var EnvelopArmor = class {
   }
 };
 
-// ../api/dist/chunk-XNXM4W4K.mjs
+// ../api/dist/chunk-4LLELFAZ.mjs
 var DateTimeScalar = new GraphQLScalarType({
   name: "DateTime",
   description: "ISO-8601 date-time string",
@@ -31086,29 +31086,22 @@ function scalarFieldResolver(field, fallback) {
 function relationFieldResolver(typeName, schemaFieldName) {
   return (parent, _args, ctx) => ctx.loaders.load(typeName, schemaFieldName, parent);
 }
-function programmaticFieldResolver(typeName, schemaFieldName, mediaFields = [], fieldKeys) {
+function programmaticFieldResolver(typeName, schemaFieldName, mediaFieldNames = [], fieldKeys) {
   return async (parent, _args, ctx) => {
     let p = ctx.programmaticMemo.get(parent);
     if (!p) {
-      p = resolveProgrammaticRow(typeName, parent, ctx, mediaFields, fieldKeys);
+      p = resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames, fieldKeys);
       ctx.programmaticMemo.set(parent, p);
     }
     return (await p)[schemaFieldName];
   };
 }
-async function resolveProgrammaticRow(typeName, parent, ctx, mediaFields, fieldKeys) {
+async function resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames, fieldKeys) {
   const toLabels = (row) => fieldKeys ? fieldKeys.toLabels(row) : row;
-  if (mediaFields.length === 0) return ctx.resolver.resolveItem(typeName, toLabels(parent));
+  if (mediaFieldNames.length === 0) return ctx.resolver.resolveItem(typeName, toLabels(parent));
   const enriched = { ...parent };
-  await Promise.all(mediaFields.map((m) => ctx.loaders.load(typeName, m.name, enriched)));
-  return ctx.resolver.resolveItem(typeName, relabelMedia(toLabels(enriched), enriched, mediaFields));
-}
-function relabelMedia(record, enriched, mediaFields) {
-  for (const { name, exposedAs } of mediaFields) {
-    if (!(name in enriched)) continue;
-    record[exposedAs] = enriched[name];
-  }
-  return record;
+  await Promise.all(mediaFieldNames.map((name) => ctx.loaders.load(typeName, name, enriched)));
+  return ctx.resolver.resolveItem(typeName, toLabels(enriched));
 }
 function collectionResolver(typeName, nameMap, fieldKeys) {
   return async (_root, args, ctx) => {
@@ -31180,7 +31173,7 @@ var MEDIA = new GraphQLObjectType({
     duration: { type: GraphQLInt, resolve: (m) => m.duration }
   }
 });
-function buildGraphQLSchema(registry, fieldKeyMaps = {}, view) {
+function buildGraphQLSchema(registry, fieldKeyMaps = {}, view, programmaticKeyMaps = fieldKeyMaps) {
   const objectTypes = /* @__PURE__ */ new Map();
   const enumTypes = /* @__PURE__ */ new Map();
   for (const [name, enumType] of Object.entries(registry.enum_types)) {
@@ -31244,9 +31237,9 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}, view) {
   }
   function buildObjectType(machineName, type) {
     const visible = viewFieldsFor(machineName, type);
-    const mediaFields = visible.filter(
-      (v) => v.field.field_type === "image" || v.field.field_type === "video" || v.field.field_type === "file"
-    ).map((v) => ({ name: v.field.name, exposedAs: v.exposedAs }));
+    const mediaFieldNames = type.fields.filter(
+      (f) => f.removed !== true && (f.field_type === "image" || f.field_type === "video" || f.field_type === "file")
+    ).map((f) => f.name);
     return new GraphQLObjectType({
       name: graphqlTypeName(machineName),
       fields: () => {
@@ -31266,7 +31259,7 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}, view) {
           const outType = outputTypeForField(field, vf.required);
           let resolve;
           if (field.field_type === "programmatic") {
-            resolve = programmaticFieldResolver(machineName, field.name, mediaFields, fieldKeyMaps[machineName]);
+            resolve = programmaticFieldResolver(machineName, field.name, mediaFieldNames, programmaticKeyMaps[machineName]);
           } else if (field.field_type === "reference" || field.field_type === "paragraph" || field.field_type === "image" || field.field_type === "video" || field.field_type === "file") {
             resolve = relationFieldResolver(machineName, field.name);
           } else {
@@ -31311,7 +31304,10 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}, view) {
   for (const [name, ct] of Object.entries(registry.content_types)) {
     const objType = objectTypes.get(name);
     const visible = viewFieldsFor(name, ct);
-    const nameMap = buildFieldNameMap(visible.map((v) => v.exposedAs));
+    const nameMap = buildFieldNameMap([
+      ...visible.map((v) => v.exposedAs),
+      ...ct.system_fields.map((s) => s.name)
+    ]);
     if (ct.only_one) {
       queryFields[singleQueryName(name)] = { type: objType, resolve: singletonResolver(name) };
       continue;
@@ -31452,7 +31448,8 @@ function createRelationLoaders(db, registry) {
         async (parents) => {
           const rows = parents;
           await resolveRelationField(db, rows, fieldName, rel, cache, true);
-          return rows.map((r) => r[fieldName]);
+          const resultKey = rel.type === "reference" || rel.type === "media" ? rel.fk_column : fieldName;
+          return rows.map((r) => r[resultKey]);
         },
         // Batch within a tick; do not memoize by parent identity (rows are mutated
         // and may recur across nesting levels).
@@ -31513,7 +31510,7 @@ function createGraphQLHandler(registry, repos, fieldKeyMaps, resolver, db, optio
       currentVersion: versioning.currentVersion
     });
   }
-  const schema = buildGraphQLSchema(registry, fieldKeyMaps, view);
+  const schema = buildGraphQLSchema(registry, fieldKeyMaps, view, versioning.currentFieldKeyMaps ?? fieldKeyMaps);
   const { plugins } = buildArmorPlugin({
     maxDepth: options.maxDepth,
     maxComplexity: options.maxComplexity

package/dist/index.js

@@ -39,7 +39,7 @@ import {
   resolveRelationField,
   sql,
   tracer
-} from "./chunk-SW3T2M64.js";
+} from "./chunk-52I54C3X.js";
 
 // ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
@@ -43958,6 +43958,16 @@ function loadEnvFile(filePath) {
   config2({ path: filePath });
 }
 
+// src/utils/project-version-model.ts
+init_esm_shims();
+function loadProjectVersionModel(schema, registry2) {
+  const snapshots = loadVersionSnapshots(schema, registry2);
+  if (!snapshots.ok) return snapshots;
+  const model = computeVersionModel({ current: registry2, snapshots: snapshots.value });
+  if (!model.ok) return model;
+  return { ok: true, value: { snapshots: snapshots.value, model: model.value } };
+}
+
 // src/commands/build.ts
 function registerBuild(program2) {
   program2.command("build").description("Run codegen and compile project to dist/").option("--env <path>", "path to .env file to load").action(async (options) => {
@@ -44018,6 +44028,11 @@ async function runBuild(options, deps) {
     parsedRoutesDef,
     parsedRoles
   );
+  const versions = loadProjectVersionModel(resolveSchemaConfig(cwd, config3), registry2);
+  if (!versions.ok) {
+    printValidationErrors(versions.errors, "Version model errors", "manguito build");
+    process.exit(1);
+  }
   printSuccess("Config loaded");
   const contentCount = parsedSchemas.filter((s) => s.schema_type === "content-type").length;
   const paragraphCount = parsedSchemas.filter((s) => s.schema_type === "paragraph-type").length;
@@ -44033,19 +44048,8 @@ async function runBuild(options, deps) {
   await generateSchemaRegistry(registry2, generatedDir);
   await generateRoutes2(registry2, generatedDir);
   await generateForms(registry2, join9(generatedDir, "forms"));
-  const schema = resolveSchemaConfig(cwd, config3);
-  const snapshots = loadVersionSnapshots(schema, registry2);
-  if (!snapshots.ok) {
-    printValidationErrors(snapshots.errors, "Snapshot errors", "manguito build");
-    process.exit(1);
-  }
-  const versionModel = computeVersionModel({ current: registry2, snapshots: snapshots.value });
-  if (!versionModel.ok) {
-    printValidationErrors(versionModel.errors, "Version model errors", "manguito build");
-    process.exit(1);
-  }
-  await generateVersionModel(versionModel.value, generatedDir);
-  printSuccess(`Version model baked (live: ${versionModel.value.live.join(", ")})`);
+  await generateVersionModel(versions.value.model, generatedDir);
+  printSuccess(`Version model baked (live: ${versions.value.model.live.join(", ")})`);
   const programmaticDir = resolve4(cwd, config3.programmatic.dir);
   const resolverFiles = existsSync3(programmaticDir) ? walkFiles(programmaticDir).filter((f) => /\.(ts|mjs|js)$/.test(f)) : [];
   await generateProgrammaticRegistry(resolverFiles, generatedDir);
@@ -47618,14 +47622,16 @@ function isPlainRow(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2) && !(v2 instanceof Date);
 }
 var MEDIA_FIELD_TYPES = /* @__PURE__ */ new Set(["image", "video", "file"]);
-function nestedTargets(fields) {
+function nestedTargets(fields, map2) {
   const out = [];
   for (const f of fields) {
     if (MEDIA_FIELD_TYPES.has(f.field_type)) continue;
     if (f.field_type !== "paragraph" && f.field_type !== "reference") continue;
     const ref = f.ui_component.ref;
     if (!ref) continue;
-    out.push({ label: f.name, target: ref });
+    const label = isColumnBacked(f) ? map2.labelFor(f.db_column.column_name) : f.name;
+    if (label === void 0) continue;
+    out.push({ label, target: ref });
   }
   return out;
 }
@@ -47643,7 +47649,7 @@ function buildProjectors(registry2, fieldKeyMaps, fallbacks) {
       const typeFallbacks = fallbacks?.[typeName];
       projectors[typeName] = {
         map: map2,
-        nested: nestedTargets(type.fields),
+        nested: nestedTargets(type.fields, map2),
         // Spread rather than assign: with exactOptionalPropertyTypes, an optional
         // property may be ABSENT but not present-and-undefined.
         ...typeFallbacks !== void 0 && { fallbacks: typeFallbacks }
@@ -47723,7 +47729,28 @@ function parseFilters(url2, validFields, columnFor) {
 function isPublished(item) {
   return item["published"] === true;
 }
-function registerPublicContentRoutes(app, registry2, repos, projectors, paths, listRateLimit, resolver) {
+function registerPublicContentRoutes(app, registry2, repos, projectors, paths, listRateLimit, resolver, resolverProjectors) {
+  const forResolver = resolverProjectors ?? projectors;
+  function pickProgrammatic(resolved, names) {
+    const out = {};
+    for (const name of names) if (name in resolved) out[name] = resolved[name];
+    return out;
+  }
+  async function respondItem(row, typeName, programmatic) {
+    const data = projectRow(row, typeName, projectors);
+    if (!resolver?.hasSchema(typeName)) return data;
+    const resolved = await resolver.resolveItem(typeName, projectRow(row, typeName, forResolver));
+    return { ...data, ...pickProgrammatic(resolved, programmatic) };
+  }
+  async function respondList(rows, typeName, programmatic) {
+    const data = rows.map((row) => projectRow(row, typeName, projectors));
+    if (!resolver?.hasSchema(typeName)) return data;
+    const resolved = await resolver.resolveList(
+      typeName,
+      rows.map((row) => projectRow(row, typeName, forResolver))
+    );
+    return data.map((d2, i) => ({ ...d2, ...pickProgrammatic(resolved[i], programmatic) }));
+  }
   function registerListRoute(path7, handler) {
     if (listRateLimit) {
       app.get(path7, listRateLimit, handler);
@@ -47747,18 +47774,29 @@ function registerPublicContentRoutes(app, registry2, repos, projectors, paths, l
     return c.json({ ok: true, data });
   });
   for (const [typeName, contentType] of Object.entries(registry2.content_types)) {
+    let translateInclude2 = function(requested) {
+      const include = [];
+      for (const field of requested) {
+        const registryName = includeNames.get(field);
+        if (registryName === void 0) return { ok: false, field };
+        include.push(registryName);
+      }
+      return { ok: true, include };
+    };
+    var translateInclude = translateInclude2;
     const basePath = contentType.default_base_path;
     const repo = repos[typeName];
     if (!repo) continue;
     const fieldKeys = projectors[typeName].map;
-    const relationFieldNames = /* @__PURE__ */ new Set();
+    const programmatic = contentType.fields.filter((f) => f.field_type === "programmatic").map((f) => f.name);
+    const includeNames = /* @__PURE__ */ new Map();
     for (const f of contentType.fields) {
       if (!RELATION_FIELD_TYPES.has(f.field_type)) continue;
       if (isColumnBacked(f)) {
         const label = fieldKeys.labelFor(f.db_column.column_name);
-        if (label !== void 0) relationFieldNames.add(label);
+        if (label !== void 0) includeNames.set(label, f.name);
       } else {
-        relationFieldNames.add(f.name);
+        includeNames.set(f.name, f.name);
       }
     }
     const filterableFieldNames = /* @__PURE__ */ new Set([
@@ -47777,8 +47815,11 @@ function registerPublicContentRoutes(app, registry2, repos, projectors, paths, l
             404
           );
         }
-        let data = projectRow(result.data[0], typeName, projectors);
-        if (resolver?.hasSchema(typeName)) data = await resolver.resolveItem(typeName, data);
+        const data = await respondItem(
+          result.data[0],
+          typeName,
+          programmatic
+        );
         return c.json({ ok: true, data });
       });
     } else {
@@ -47835,21 +47876,20 @@ function registerPublicContentRoutes(app, registry2, repos, projectors, paths, l
             400
           );
         }
-        const include = parseInclude(c.req.query("include"));
-        for (const field of include) {
-          if (!relationFieldNames.has(field)) {
-            return c.json(
-              {
-                ok: false,
-                error: {
-                  code: "INVALID_INCLUDE_FIELD",
-                  message: `'${field}' is not a valid relation field`
-                }
-              },
-              400
-            );
-          }
+        const translated = translateInclude2(parseInclude(c.req.query("include")));
+        if (!translated.ok) {
+          return c.json(
+            {
+              ok: false,
+              error: {
+                code: "INVALID_INCLUDE_FIELD",
+                message: `'${translated.field}' is not a valid relation field`
+              }
+            },
+            400
+          );
         }
+        const include = translated.include;
         const sortColumn = fieldKeys.labels.includes(sortBy) ? fieldKeys.columnFor(sortBy) : sortBy;
         const result = await repo.findMany({
           published_only: true,
@@ -47860,29 +47900,25 @@ function registerPublicContentRoutes(app, registry2, repos, projectors, paths, l
           filters: filtersResult.filters,
           include
         });
-        const labeled = result.data.map(
-          (row) => projectRow(row, typeName, projectors)
-        );
-        const data = resolver?.hasSchema(typeName) ? await resolver.resolveList(typeName, labeled) : labeled;
+        const data = await respondList(result.data, typeName, programmatic);
         return c.json({ ...result, data });
       });
       app.get(paths.item(basePath), async (c) => {
         const slug = c.req.param("slug");
-        const include = parseInclude(c.req.query("include"));
-        for (const field of include) {
-          if (!relationFieldNames.has(field)) {
-            return c.json(
-              {
-                ok: false,
-                error: {
-                  code: "INVALID_INCLUDE_FIELD",
-                  message: `'${field}' is not a valid relation field`
-                }
-              },
-              400
-            );
-          }
+        const translated = translateInclude2(parseInclude(c.req.query("include")));
+        if (!translated.ok) {
+          return c.json(
+            {
+              ok: false,
+              error: {
+                code: "INVALID_INCLUDE_FIELD",
+                message: `'${translated.field}' is not a valid relation field`
+              }
+            },
+            400
+          );
         }
+        const include = translated.include;
         const item = await repo.findBySlug(slug, include);
         if (!item || !isPublished(item)) {
           return c.json(
@@ -47893,15 +47929,15 @@ function registerPublicContentRoutes(app, registry2, repos, projectors, paths, l
             404
           );
         }
-        let data = projectRow(item, typeName, projectors);
-        if (resolver?.hasSchema(typeName)) data = await resolver.resolveItem(typeName, data);
+        const data = await respondItem(item, typeName, programmatic);
         return c.json({ ok: true, data });
       });
     }
   }
-  for (const [typeName] of Object.entries(registry2.taxonomy_types)) {
+  for (const [typeName, taxonomyType] of Object.entries(registry2.taxonomy_types)) {
     const repo = repos[typeName];
     if (!repo) continue;
+    const programmatic = taxonomyType.fields.filter((f) => f.field_type === "programmatic").map((f) => f.name);
     registerListRoute(paths.taxonomyCollection(typeName), async (c) => {
       const pagination = parsePagination(c.req.query("page"), c.req.query("per_page"));
       if (!pagination.ok) {
@@ -47921,10 +47957,7 @@ function registerPublicContentRoutes(app, registry2, repos, projectors, paths, l
         page: pagination.page,
         per_page: pagination.per_page
       });
-      const labeled = result.data.map(
-        (row) => projectRow(row, typeName, projectors)
-      );
-      const data = resolver?.hasSchema(typeName) ? await resolver.resolveList(typeName, labeled) : labeled;
+      const data = await respondList(result.data, typeName, programmatic);
       return c.json({ ...result, data });
     });
     app.get(paths.taxonomyItem(typeName), async (c) => {
@@ -47939,8 +47972,7 @@ function registerPublicContentRoutes(app, registry2, repos, projectors, paths, l
           404
         );
       }
-      let data = projectRow(item, typeName, projectors);
-      if (resolver?.hasSchema(typeName)) data = await resolver.resolveItem(typeName, data);
+      const data = await respondItem(item, typeName, programmatic);
       return c.json({ ok: true, data });
     });
   }
@@ -49702,7 +49734,7 @@ function registerUserRoutes(app, db, requirePermission, requireHierarchy) {
 }
 var API_VERSION = (() => {
   try {
-    return "0.6.0";
+    return "0.7.0";
   } catch {
     return "0.0.0";
   }
@@ -50343,7 +50375,7 @@ function createCmsApp(options) {
         app.use(path7, attachDeprecationHeaders);
       }
     }
-    registerPublicContentRoutes(app, registry2, surface.repos, surface.projectors, surface.paths, listRateLimit, programmaticResolver);
+    registerPublicContentRoutes(app, registry2, surface.repos, surface.projectors, surface.paths, listRateLimit, programmaticResolver, projectors);
   }
   if (options.versions !== void 0) {
     app.all(`${prefix}/:version/*`, async (c, next) => {
@@ -50385,7 +50417,7 @@ function createCmsApp(options) {
       handler: null,
       error: null
     }));
-    const ready = import("./handler-XZVDLKZ2-2TIH4GG7.js").then(({ createGraphQLHandler }) => {
+    const ready = import("./handler-GED3I7Z2-HZAD77OI.js").then(({ createGraphQLHandler }) => {
       gqlPasses.forEach((pass, i) => {
         const mount = mounts[i];
         try {
@@ -50409,7 +50441,8 @@ function createCmsApp(options) {
               endpoint: mount.path,
               currentVersion: model.current,
               ...projection !== void 0 && { projection },
-              ...currentProjection !== void 0 && { currentProjection }
+              ...currentProjection !== void 0 && { currentProjection },
+              currentFieldKeyMaps: fieldKeyMaps
             }
           );
         } catch (err) {
@@ -50712,18 +50745,12 @@ async function runDev(options, deps) {
   await generateRoutes2(registry2, manguitoDir);
   await generateForms(registry2, join13(manguitoDir, "forms"));
   await generateNav(registry2, manguitoDir);
-  const schemaConfig = resolveSchemaConfig(cwd, config3);
-  const snapshotsResult = loadVersionSnapshots(schemaConfig, registry2);
-  if (!snapshotsResult.ok) {
-    printValidationErrors(snapshotsResult.errors, "Version snapshot errors", "manguito version:diff");
+  const versionsResult = loadProjectVersionModel(resolveSchemaConfig(cwd, config3), registry2);
+  if (!versionsResult.ok) {
+    printValidationErrors(versionsResult.errors, "Version model errors", "manguito validate");
     process.exit(1);
   }
-  const versionModelResult = computeVersionModel({ current: registry2, snapshots: snapshotsResult.value });
-  if (!versionModelResult.ok) {
-    printValidationErrors(versionModelResult.errors, "Version model errors", "manguito version:diff");
-    process.exit(1);
-  }
-  const versionModel = reduceVersionModel(versionModelResult.value);
+  const versionModel = reduceVersionModel(versionsResult.value.model);
   const resolverMap = await loadProgrammaticResolvers(cwd, config3.programmatic.dir);
   const adapter = createCmsApp({
     name: config3.name,
@@ -50862,20 +50889,13 @@ async function onSchemaFileChange(args) {
   await generateRoutes2(registry2, manguitoDir);
   await generateForms(registry2, join13(manguitoDir, "forms"));
   await generateNav(registry2, manguitoDir);
-  const schemaConfig = resolveSchemaConfig(cwd, config3);
-  const snapshotsResult = loadVersionSnapshots(schemaConfig, registry2);
-  if (!snapshotsResult.ok) {
-    printValidationErrors(snapshotsResult.errors, "Version snapshot errors", "manguito version:diff");
+  const versionsResult = loadProjectVersionModel(resolveSchemaConfig(cwd, config3), registry2);
+  if (!versionsResult.ok) {
+    printValidationErrors(versionsResult.errors, "Version model errors", "manguito validate");
     process.stderr.write("\u26A0 Changes not applied.\n");
     return;
   }
-  const versionModelResult = computeVersionModel({ current: registry2, snapshots: snapshotsResult.value });
-  if (!versionModelResult.ok) {
-    printValidationErrors(versionModelResult.errors, "Version model errors", "manguito version:diff");
-    process.stderr.write("\u26A0 Changes not applied.\n");
-    return;
-  }
-  const versionModel = reduceVersionModel(versionModelResult.value);
+  const versionModel = reduceVersionModel(versionsResult.value.model);
   try {
     await runDevMigration(drizzleConfigPath);
   } catch (err) {
@@ -51333,10 +51353,16 @@ async function runValidate(options, deps) {
       parsedRoutesDef = routesParseResult.value;
     }
   }
+  let liveVersions = null;
   if (allErrors.length === 0 && parsedRoles !== null && parsedRoutesDef !== null) {
     const registry2 = buildSchemaRegistry(parsedSchemas, parsedRoutesDef, parsedRoles);
     const crossRefErrors = validateCrossReferences(registry2, config3.api.media?.max_file_size);
     allErrors.push(...crossRefErrors);
+    if (crossRefErrors.length === 0) {
+      const versions = loadProjectVersionModel(resolveSchemaConfig(cwd, config3), registry2);
+      if (versions.ok) liveVersions = versions.value.model.live;
+      else allErrors.push(...versions.errors);
+    }
   }
   if (allErrors.length > 0) {
     printValidationErrors(allErrors, "Validation errors", "manguito validate");
@@ -51351,6 +51377,7 @@ async function runValidate(options, deps) {
   );
   printSuccess("roles.json valid");
   printSuccess("routes.json valid");
+  if (liveVersions !== null) printSuccess(`Versions valid (live: ${liveVersions.join(", ")})`);
   process.stdout.write("\nNo errors found.\n");
 }
 
@@ -51664,7 +51691,7 @@ function formatField(change) {
   }
 }
 function formatSchemaChange(change) {
-  const header = change.from === null ? `Working schema \u2014 nothing has been cut yet, so ${change.to} would be the first version` : `Working schema vs ${change.from} (highest snapshot) \u2014 would become ${change.to}`;
+  const header = change.from === null ? `Working schema \u2014 nothing has been created yet, so ${change.to} would be the first version` : `Working schema vs ${change.from} (highest snapshot) \u2014 would become ${change.to}`;
   if (change.identical) {
     return `${header}
 
@@ -51678,6 +51705,38 @@ No column added, renamed, tombstoned or restored.`;
   });
   return [header, "", ...blocks].join("\n");
 }
+function driftSummary(change) {
+  const counts = { renamed: 0, tombstoned: 0, added: 0, restored: 0 };
+  for (const type of change.types) {
+    for (const field of type.fields) counts[field.kind]++;
+  }
+  const parts = [];
+  if (counts.renamed > 0) parts.push(`${counts.renamed} renamed`);
+  if (counts.tombstoned > 0) parts.push(`${counts.tombstoned} removed`);
+  if (counts.added > 0) parts.push(`${counts.added} added`);
+  if (counts.restored > 0) parts.push(`${counts.restored} restored`);
+  if (parts.length > 0) return `${parts.join(", ")} since`;
+  if (change.identical) return "identical to current";
+  const newTypes = change.types.filter((t) => t.status === "added").length;
+  return `${newTypes} new type${newTypes === 1 ? "" : "s"} since`;
+}
+function formatVersionList(input2) {
+  const { prefix, current, older } = input2;
+  if (older.length === 0) {
+    return `No versions created yet. Your working schema is ${current}, served at ${prefix}/${current} and ${prefix}.
+Run \`manguito version:create\` before making a breaking change.`;
+  }
+  const rows = [
+    ...older.map((o) => [o.version, `${prefix}/${o.version}`, driftSummary(o.change)]),
+    [current, `${prefix}/${current}`, `current \u2014 also ${prefix}`]
+  ];
+  const nameWidth = Math.max(...rows.map((r) => r[0].length));
+  const pathWidth = Math.max(...rows.map((r) => r[1].length));
+  return [
+    `Live versions (${rows.length}):`,
+    ...rows.map(([name, url2, note]) => `  ${name.padEnd(nameWidth)}  ${url2.padEnd(pathWidth)}  ${note}`)
+  ].join("\n");
+}
 
 // src/commands/version-fs.ts
 init_esm_shims();
@@ -51735,17 +51794,19 @@ async function loadVersionContext(options, deps, command) {
   const config3 = await resolveConfig(deps.cwd);
   const schema = resolveSchemaConfig(deps.cwd, config3);
   const registry2 = loadWorkingRegistry(deps.cwd, config3, command);
-  const snapshots = loadVersionSnapshots(schema, registry2);
-  if (!snapshots.ok) {
-    printValidationErrors(snapshots.errors, "Snapshot errors", command);
+  const versions = loadProjectVersionModel(schema, registry2);
+  if (!versions.ok) {
+    printValidationErrors(versions.errors, "Version model errors", command);
     process.exit(1);
   }
-  const model = computeVersionModel({ current: registry2, snapshots: snapshots.value });
-  if (!model.ok) {
-    printValidationErrors(model.errors, "Version model errors", command);
-    process.exit(1);
-  }
-  return { schema, registry: registry2, snapshots: snapshots.value, model: model.value };
+  return {
+    schema,
+    registry: registry2,
+    snapshots: versions.value.snapshots,
+    model: versions.value.model,
+    // Same default `dev` uses: the prefix the served routes actually carry.
+    apiPrefix: config3.api.prefix ?? "/api"
+  };
 }
 function orphanedTombstoneErrors(input2) {
   const remaining = input2.snapshots.filter((s) => s.version !== input2.retiring);
@@ -51753,14 +51814,22 @@ function orphanedTombstoneErrors(input2) {
   if (model.ok) return [];
   return model.errors.filter((e) => e.code === "ORPHANED_TOMBSTONE");
 }
+var VERSION_CUT_DEPRECATION = "`version:cut` is deprecated \u2014 use `version:create`. It will be removed in a future release.\n";
 function registerVersion(program2) {
-  program2.command("version:diff").description("Show what cutting a new version would freeze").option("--env <path>", "path to .env file to load").action(async (options) => {
+  program2.command("version:diff").description("Show what creating a new version would freeze").option("--env <path>", "path to .env file to load").action(async (options) => {
     await runVersionDiff(options, { cwd: process.cwd() });
   });
-  program2.command("version:cut").description("Freeze the working schema as a new version").option("--env <path>", "path to .env file to load").option("--yes", "skip the confirmation prompt").action(async (options) => {
-    await runVersionCut(options, { cwd: process.cwd(), prompt: createPromptAdapter() });
+  program2.command("version:create").description("Create a version: freeze the working schema so it keeps being served unchanged").option("--env <path>", "path to .env file to load").option("--yes", "skip the confirmation prompt").action(async (options) => {
+    await runVersionCreate(options, { cwd: process.cwd(), prompt: createPromptAdapter() });
+  });
+  program2.command("version:list").description("List the versions being served and how far each is behind the working schema").option("--env <path>", "path to .env file to load").action(async (options) => {
+    await runVersionList(options, { cwd: process.cwd() });
+  });
+  program2.command("version:cut", { hidden: true }).option("--env <path>", "path to .env file to load").option("--yes", "skip the confirmation prompt").action(async (options) => {
+    process.stderr.write(VERSION_CUT_DEPRECATION);
+    await runVersionCreate(options, { cwd: process.cwd(), prompt: createPromptAdapter() });
   });
-  program2.command("version:retire <version>").description("Stop serving a cut version and delete its snapshot").option("--env <path>", "path to .env file to load").option("--yes", "skip the confirmation prompt").action(async (version3, options) => {
+  program2.command("version:retire <version>").description("Stop serving a created version and delete its snapshot").option("--env <path>", "path to .env file to load").option("--yes", "skip the confirmation prompt").action(async (version3, options) => {
     await runVersionRetire(version3, options, { cwd: process.cwd(), prompt: createPromptAdapter() });
   });
 }
@@ -51776,15 +51845,15 @@ async function runVersionDiff(options, deps) {
   if (change.identical) {
     process.stdout.write(
       `
-Nothing to cut \u2014 no column was added, renamed, tombstoned or restored, so ${ctx.model.current} would expose the same contract.
+Nothing to create \u2014 no column was added, renamed, tombstoned or restored, so ${ctx.model.current} would expose the same contract.
 `
     );
     return;
   }
-  printSuccess(`Cutting now would create ${ctx.schema.base_path}/versions/${ctx.model.current}/`);
+  printSuccess(`Creating a version now would write ${ctx.schema.base_path}/versions/${ctx.model.current}/`);
 }
-async function runVersionCut(options, deps) {
-  const ctx = await loadVersionContext(options, deps, "manguito version:cut");
+async function runVersionCreate(options, deps) {
+  const ctx = await loadVersionContext(options, deps, "manguito version:create");
   const from = highestSnapshot(ctx.snapshots);
   const version3 = ctx.model.current;
   const change = describeSchemaChange({
@@ -51793,8 +51862,8 @@ async function runVersionCut(options, deps) {
   });
   if (change.identical) {
     printGuidedError(
-      `No column was added, renamed, tombstoned or restored since ${from?.version ?? "the last cut"} \u2014 cutting ${version3} would freeze an identical contract.`,
-      "Changes to paragraph, programmatic, many-to-many and enum definitions are not versioned and need no new version. A live version commits you to retaining every column it exposes, so cut only when a column actually changed \u2014 or run `manguito version:retire <version>` if you meant to shrink the live set."
+      `No column was added, renamed, tombstoned or restored since ${from?.version ?? "the working schema began"} \u2014 creating ${version3} would freeze an identical contract.`,
+      "Changes to paragraph, programmatic, many-to-many and enum definitions are not versioned and need no new version. A live version commits you to retaining every column it exposes, so create one only when a column actually changed \u2014 or run `manguito version:retire <version>` if you meant to shrink the live set."
     );
     process.exit(1);
   }
@@ -51803,22 +51872,32 @@ async function runVersionCut(options, deps) {
   if (fs6.existsSync(target)) {
     printGuidedError(
       `${target} already exists.`,
-      "A snapshot directory is never overwritten. Remove or rename it, then run version:cut again."
+      "A snapshot directory is never overwritten. Remove or rename it, then run version:create again."
     );
     process.exit(1);
   }
   process.stdout.write(`${formatSchemaChange(change)}
 
 `);
-  const live = [...ctx.model.live.filter((v2) => v2 !== version3), version3].join(" ");
+  const next = `v${Number.parseInt(version3.slice(1), 10) + 1}`;
+  const liveAfter = [...ctx.model.live.filter((v2) => v2 !== version3), version3, next];
+  if (from === null) {
+    const prefix = ctx.apiPrefix;
+    process.stdout.write(
+      `This creates ${version3} from your working schema. ${prefix}/${version3} keeps serving it
+unchanged; your working schema becomes ${next}, served at ${prefix}/${next} and ${prefix}.
+
+`
+    );
+  }
   process.stdout.write(
-    `After cutting, ${live} are live. Every column those versions expose must stay in the
-schema \u2014 as a live field or a tombstone \u2014 until you retire them.
+    `After creating ${version3}, these versions are live: ${liveAfter.join(" ")}. Every column they
+expose must stay in the schema \u2014 as a live field or a tombstone \u2014 until you retire them.
 
 `
   );
   if (options.yes !== true) {
-    const ok = await deps.prompt.confirm(`Freeze the working schema as ${version3}?`);
+    const ok = await deps.prompt.confirm(`Create ${version3} from the working schema?`);
     if (!ok) {
       process.stdout.write("Cancelled. Nothing was written.\n");
       return;
@@ -51833,8 +51912,19 @@ schema \u2014 as a live field or a tombstone \u2014 until you retire them.
     );
     process.exit(1);
   }
-  printSuccess(`Froze the working schema as ${version3} at ${target}`);
-  process.stdout.write(`Live: ${live}.  Working schema is now v${Number.parseInt(version3.slice(1), 10) + 1}.
+  printSuccess(`Created ${version3} at ${target}`);
+  process.stdout.write(`Live: ${liveAfter.join(" ")}.  Working schema is now ${next}.
+`);
+}
+async function runVersionList(options, deps) {
+  const ctx = await loadVersionContext(options, deps, "manguito version:list");
+  const current = ctx.model.current;
+  const versionNumber3 = (v2) => Number.parseInt(v2.slice(1), 10);
+  const older = [...ctx.snapshots].sort((a2, b2) => versionNumber3(a2.version) - versionNumber3(b2.version)).map((s) => ({
+    version: s.version,
+    change: describeSchemaChange({ from: s, to: { version: current, registry: ctx.registry } })
+  }));
+  process.stdout.write(`${formatVersionList({ prefix: ctx.apiPrefix, current, older })}
 `);
 }
 async function runVersionRetire(version3, options, deps) {
@@ -51846,8 +51936,8 @@ async function runVersionRetire(version3, options, deps) {
   if (!ctx.snapshots.some((s) => s.version === version3)) {
     const existing = ctx.snapshots.map((s) => s.version).join(", ");
     printGuidedError(
-      `${version3} is not a cut version.`,
-      existing === "" ? "No versions have been cut yet \u2014 run `manguito version:cut` first." : `Cut versions: ${existing}.`
+      `${version3} is not a created version.`,
+      existing === "" ? "No versions have been created yet \u2014 run `manguito version:create` first." : `Created versions: ${existing}.`
     );
     process.exit(1);
   }
@@ -51855,8 +51945,8 @@ async function runVersionRetire(version3, options, deps) {
   if (highest !== null && highest.version === version3) {
     const target = path6.join(ctx.schema.base_path, "versions", version3);
     printGuidedError(
-      `${version3} is the newest cut version and cannot be retired.`,
-      `The working schema is ${ctx.model.current} because ${version3} is the highest snapshot \u2014 retiring it would renumber the working schema back onto ${version3}, and anyone pinned to ${version3} would get a different contract. Cutting a version with a real contract change makes ${version3} retirable. If ${version3} was cut in error, delete ${target} by hand \u2014 safe only while nothing yet consumes ${version3}, since deleting the newest snapshot renumbers the working schema back onto it.`
+      `${version3} is the newest created version and cannot be retired.`,
+      `The working schema is ${ctx.model.current} because ${version3} is the highest snapshot \u2014 retiring it would renumber the working schema back onto ${version3}, and anyone pinned to ${version3} would get a different contract. Creating a newer version with a real contract change makes ${version3} retirable. If ${version3} was created in error, delete ${target} by hand \u2014 safe only while nothing yet consumes ${version3}, since deleting the newest snapshot renumbers the working schema back onto it.`
     );
     process.exit(1);
   }
@@ -51882,7 +51972,7 @@ longer exposed by any live version. You must then delete these fields:
 `);
     }
     process.stdout.write(
-      "Until you do, `manguito validate` will report ORPHANED_TOMBSTONE. Deleting them\nshrinks the union and lets the next migration DROP those columns.\n\n"
+      "Until you do, `manguito validate` and `manguito build` will fail. Deleting them\nshrinks the union and lets the next migration DROP those columns.\n\n"
     );
   }
   if (options.yes !== true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobbykim/manguito-cms-cli",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "license": "MIT",
   "author": "Bobby Kim <bobby.sihun.kim@gmail.com>",
   "homepage": "https://github.com/bobbykim89/manguito-cms",
@@ -29,10 +29,10 @@
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
     "vite": "^8.1.3",
-    "@bobbykim/manguito-cms-api": "0.6.0",
+    "@bobbykim/manguito-cms-admin": "0.4.3",
+    "@bobbykim/manguito-cms-api": "0.7.0",
     "@bobbykim/manguito-cms-db": "0.1.6",
-    "@bobbykim/manguito-cms-core": "0.6.0",
-    "@bobbykim/manguito-cms-admin": "0.4.3"
+    "@bobbykim/manguito-cms-core": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.5",
@@ -42,7 +42,7 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
-    "test": "dotenv -e .env.test -- vitest run",
+    "test": "dotenv -e ../../.env.test -- vitest run",
     "lint": "eslint src",
     "typecheck": "tsc --noEmit"
   }