@specverse/engines 4.1.30 → 4.2.0

package/dist/libs/instance-factories/applications/templates/react-starter/form-body-composer.js

@@ -0,0 +1,190 @@
+import { METADATA_FIELDS } from "@specverse/runtime/views/core";
+const AUTO_GENERATED_FIELD_NAMES = new Set(METADATA_FIELDS);
+function composeFormBody(context) {
+  const belongsTo = extractBelongsTo(context.model);
+  const shadowedFKs = new Set(belongsTo.map((rel) => `${rel}Id`));
+  const fields = selectFormFields(context.model, shadowedFKs);
+  const lines = [];
+  lines.push('<div className="space-y-4">');
+  if (fields.length === 0 && belongsTo.length === 0) {
+    lines.push('  <p className="text-sm text-gray-400">No editable fields for this model.</p>');
+    lines.push("</div>");
+    return lines.join("\n");
+  }
+  for (const field of fields) {
+    lines.push(...renderInput(field));
+  }
+  if (belongsTo.length > 0) {
+    lines.push("");
+    lines.push("  {/* TODO: swap these text inputs for <select>s that load the related");
+    lines.push("      entities. See useEntitiesQuery(TargetModel) in the runtime hooks. */}");
+    for (const rel of belongsTo) {
+      lines.push(...renderInput({
+        name: `${rel}Id`,
+        label: humanize(rel),
+        type: "String",
+        required: true
+      }));
+    }
+  }
+  lines.push("</div>");
+  return lines.join("\n");
+}
+function selectFormFields(model, skip = /* @__PURE__ */ new Set()) {
+  const out = [];
+  const attrs = model.attributes ?? {};
+  for (const [name, rawDef] of Object.entries(attrs)) {
+    if (AUTO_GENERATED_FIELD_NAMES.has(name)) continue;
+    if (skip.has(name)) continue;
+    const def = rawDef;
+    if (def?.auto) continue;
+    const type = def?.type ?? parseTypeFromConvention(def) ?? "String";
+    const required = def?.required === true || hasConventionFlag(def, "required");
+    const values = def?.values;
+    const maxLength = def?.maxLength ?? def?.max;
+    const isLongString = typeof maxLength === "number" && maxLength > 100;
+    out.push({
+      name,
+      label: humanize(name),
+      type: normalizeType(type),
+      required,
+      values,
+      isLongString
+    });
+  }
+  return out;
+}
+function parseTypeFromConvention(def) {
+  if (typeof def === "string") {
+    const first = def.trim().split(/\s+/)[0];
+    return first;
+  }
+  return void 0;
+}
+function hasConventionFlag(def, flag) {
+  if (typeof def === "string") {
+    return def.split(/\s+/).includes(flag);
+  }
+  return false;
+}
+function normalizeType(type) {
+  return type.replace(/[^A-Za-z].*$/, "");
+}
+function extractBelongsTo(model) {
+  const rels = model.relationships ?? {};
+  const out = [];
+  for (const [name, def] of Object.entries(rels)) {
+    if (def?.type === "belongsTo") out.push(name);
+  }
+  return out;
+}
+const INPUT_CLS = "w-full rounded border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500 dark:border-gray-600 dark:bg-gray-800 dark:text-gray-100";
+const LABEL_CLS = "block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1";
+function renderInput(field) {
+  const requiredMark = field.required ? " *" : "";
+  const reqAttr = field.required ? " required" : "";
+  if (field.values && field.values.length > 0) {
+    const options = field.values.map((v) => `      <option value="${escapeAttr(v)}">${escapeText(v)}</option>`).join("\n");
+    return [
+      "  <div>",
+      `    <label className="${LABEL_CLS}" htmlFor="${field.name}">${field.label}${requiredMark}</label>`,
+      `    <select`,
+      `      id="${field.name}"`,
+      `      className="${INPUT_CLS}"`,
+      `      value={String((formData as any).${field.name} ?? '')}`,
+      `      onChange={e => handleChange('${field.name}', e.target.value)}${reqAttr}`,
+      `    >`,
+      `      <option value="">\u2014 choose \u2014</option>`,
+      options,
+      `    </select>`,
+      "  </div>"
+    ];
+  }
+  if (field.type === "Text" || field.isLongString) {
+    return [
+      "  <div>",
+      `    <label className="${LABEL_CLS}" htmlFor="${field.name}">${field.label}${requiredMark}</label>`,
+      `    <textarea`,
+      `      id="${field.name}"`,
+      `      className="${INPUT_CLS}"`,
+      `      rows={4}`,
+      `      value={String((formData as any).${field.name} ?? '')}`,
+      `      onChange={e => handleChange('${field.name}', e.target.value)}${reqAttr}`,
+      `    />`,
+      "  </div>"
+    ];
+  }
+  if (field.type === "Boolean") {
+    return [
+      "  <div>",
+      `    <label className="inline-flex items-center gap-2">`,
+      `      <input`,
+      `        id="${field.name}"`,
+      `        type="checkbox"`,
+      `        checked={Boolean((formData as any).${field.name})}`,
+      `        onChange={e => handleChange('${field.name}', e.target.checked)}`,
+      `      />`,
+      `      <span className="text-sm text-gray-700 dark:text-gray-300">${field.label}${requiredMark}</span>`,
+      `    </label>`,
+      "  </div>"
+    ];
+  }
+  const inputType = mapInputType(field.type);
+  return [
+    "  <div>",
+    `    <label className="${LABEL_CLS}" htmlFor="${field.name}">${field.label}${requiredMark}</label>`,
+    `    <input`,
+    `      id="${field.name}"`,
+    `      type="${inputType}"`,
+    `      className="${INPUT_CLS}"`,
+    `      value={String((formData as any).${field.name} ?? '')}`,
+    `      onChange={e => handleChange('${field.name}', ${coerceOnChange(field.type)})}${reqAttr}`,
+    `    />`,
+    "  </div>"
+  ];
+}
+function mapInputType(type) {
+  switch (type) {
+    case "Integer":
+    case "Float":
+    case "Number":
+    case "Money":
+      return "number";
+    case "DateTime":
+      return "datetime-local";
+    case "Date":
+      return "date";
+    case "Email":
+      return "email";
+    case "URL":
+      return "url";
+    case "String":
+    case "UUID":
+    default:
+      return "text";
+  }
+}
+function coerceOnChange(type) {
+  switch (type) {
+    case "Integer":
+    case "Number":
+      return "e.target.value === '' ? undefined : Number(e.target.value)";
+    case "Float":
+    case "Money":
+      return "e.target.value === '' ? undefined : parseFloat(e.target.value)";
+    default:
+      return "e.target.value";
+  }
+}
+function humanize(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()).trim();
+}
+function escapeAttr(s) {
+  return s.replace(/"/g, "&quot;");
+}
+function escapeText(s) {
+  return s.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export {
+  composeFormBody
+};

package/dist/libs/instance-factories/applications/templates/react-starter/helpers-emitter.js

@@ -0,0 +1,45 @@
+function emitEntityDisplay() {
+  return `/**
+ * Pick the best human-readable label for an entity.
+ *
+ * Walks a prioritized list of candidate fields. Falls back to a
+ * truncated id if none match. Inlined into this project by
+ * @specverse/realize (ReactAppStarter); edit freely \u2014 nothing in
+ * the factory's regeneration will clobber your edits.
+ */
+export function getEntityDisplayName(entity: Record<string, unknown> | null | undefined): string {
+  if (!entity) return '';
+
+  const candidates = ['name', 'title', 'displayName', 'label', 'username', 'email'];
+  for (const key of candidates) {
+    const value = entity[key];
+    if (typeof value === 'string' && value.trim().length > 0) {
+      return value;
+    }
+  }
+
+  const id = entity.id;
+  if (typeof id === 'string') {
+    return id.length > 8 ? id.slice(0, 8) + '\u2026' : id;
+  }
+  return id != null ? String(id) : '';
+}
+
+/**
+ * Map an entity id to the display name of the record with that id in
+ * a provided list. Handy for resolving belongsTo FK columns in
+ * list / detail views.
+ */
+export function resolveEntityDisplayName(
+  id: unknown,
+  records: ReadonlyArray<Record<string, unknown>>
+): string {
+  if (id == null) return '';
+  const match = records.find(r => r.id === id);
+  return match ? getEntityDisplayName(match) : String(id);
+}
+`;
+}
+export {
+  emitEntityDisplay
+};

package/dist/libs/instance-factories/applications/templates/react-starter/html-to-jsx.js

@@ -0,0 +1,192 @@
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+const ATTRIBUTE_RENAMES = {
+  class: "className",
+  for: "htmlFor",
+  tabindex: "tabIndex",
+  readonly: "readOnly",
+  maxlength: "maxLength",
+  minlength: "minLength",
+  colspan: "colSpan",
+  rowspan: "rowSpan",
+  autofocus: "autoFocus",
+  autocomplete: "autoComplete",
+  cellpadding: "cellPadding",
+  cellspacing: "cellSpacing",
+  enctype: "encType",
+  usemap: "useMap",
+  accesskey: "accessKey",
+  contenteditable: "contentEditable",
+  spellcheck: "spellCheck",
+  crossorigin: "crossOrigin",
+  srcset: "srcSet",
+  srcdoc: "srcDoc"
+};
+function htmlToJsx(html) {
+  if (!html) return "";
+  const tokens = tokenize(html);
+  return tokens.map(transformToken).join("");
+}
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  const n = input.length;
+  while (i < n) {
+    const ch = input[i];
+    if (ch === "<") {
+      const tagStart = i;
+      i++;
+      let quote = null;
+      while (i < n) {
+        const c = input[i];
+        if (quote) {
+          if (c === quote) quote = null;
+          i++;
+          continue;
+        }
+        if (c === '"' || c === "'") {
+          quote = c;
+          i++;
+          continue;
+        }
+        if (c === ">") {
+          i++;
+          break;
+        }
+        i++;
+      }
+      const raw = input.slice(tagStart, i);
+      const isClosing = raw.startsWith("</");
+      const isSelfClosed = raw.endsWith("/>");
+      const tagName = parseTagName(raw);
+      tokens.push({ kind: "tag", raw, tagName, isClosing, isSelfClosed });
+    } else {
+      const textStart = i;
+      while (i < n && input[i] !== "<") i++;
+      tokens.push({ kind: "text", value: input.slice(textStart, i) });
+    }
+  }
+  return tokens;
+}
+function parseTagName(tagRaw) {
+  const m = tagRaw.match(/^<\/?([a-zA-Z][a-zA-Z0-9-]*)/);
+  return m ? m[1].toLowerCase() : "";
+}
+function transformToken(token) {
+  if (token.kind === "text") {
+    return token.value;
+  }
+  return transformTag(token.raw, token.tagName, token.isClosing, token.isSelfClosed);
+}
+function transformTag(raw, tagName, isClosing, isSelfClosed) {
+  if (isClosing) {
+    return raw;
+  }
+  const inner = isSelfClosed ? raw.slice(1, -2).trimEnd() : raw.slice(1, -1);
+  const nameMatch = inner.match(/^([a-zA-Z][a-zA-Z0-9-]*)(.*)$/s);
+  if (!nameMatch) return raw;
+  const elementName = nameMatch[1];
+  const attrsSection = nameMatch[2];
+  const attrs = parseAttributes(attrsSection);
+  const renamedAttrs = attrs.map(renameAttribute);
+  const rebuiltAttrs = serializeAttributes(renamedAttrs);
+  const shouldSelfClose = VOID_ELEMENTS.has(tagName) && !isSelfClosed;
+  if (shouldSelfClose || isSelfClosed) {
+    return `<${elementName}${rebuiltAttrs} />`;
+  }
+  return `<${elementName}${rebuiltAttrs}>`;
+}
+function parseAttributes(section) {
+  const attrs = [];
+  let i = 0;
+  const n = section.length;
+  while (i < n) {
+    while (i < n && /\s/.test(section[i])) i++;
+    if (i >= n) break;
+    const nameStart = i;
+    while (i < n && /[a-zA-Z0-9:_-]/.test(section[i])) i++;
+    if (i === nameStart) {
+      i++;
+      continue;
+    }
+    const name = section.slice(nameStart, i);
+    let j = i;
+    while (j < n && /\s/.test(section[j])) j++;
+    if (j >= n || section[j] !== "=") {
+      attrs.push({ name });
+      continue;
+    }
+    i = j + 1;
+    while (i < n && /\s/.test(section[i])) i++;
+    if (i >= n) {
+      attrs.push({ name });
+      break;
+    }
+    const vc = section[i];
+    if (vc === '"' || vc === "'") {
+      const quote = vc;
+      i++;
+      const valStart = i;
+      while (i < n && section[i] !== quote) i++;
+      const value = section.slice(valStart, i);
+      if (i < n) i++;
+      attrs.push({ name, value, quote });
+    } else {
+      const valStart = i;
+      while (i < n && !/[\s/>]/.test(section[i])) i++;
+      const value = section.slice(valStart, i);
+      attrs.push({ name, value });
+    }
+  }
+  return attrs;
+}
+function renameAttribute(attr) {
+  const lower = attr.name.toLowerCase();
+  const newName = ATTRIBUTE_RENAMES[lower] ?? attr.name;
+  if (lower === "style" && attr.value !== void 0) {
+    return { name: newName, value: cssStringToJsxObject(attr.value), quote: void 0 };
+  }
+  return { ...attr, name: newName };
+}
+function serializeAttributes(attrs) {
+  if (attrs.length === 0) return "";
+  const parts = attrs.map((attr) => {
+    if (attr.value === void 0) return ` ${attr.name}`;
+    if (attr.value.startsWith("{{") && attr.value.endsWith("}}")) {
+      return ` ${attr.name}=${attr.value}`;
+    }
+    const q = attr.quote ?? '"';
+    return ` ${attr.name}=${q}${attr.value}${q}`;
+  });
+  return parts.join("");
+}
+function cssStringToJsxObject(css) {
+  const declarations = css.split(";").map((d) => d.trim()).filter((d) => d.length > 0);
+  if (declarations.length === 0) return "{{}}";
+  const entries = declarations.map((decl) => {
+    const colonIdx = decl.indexOf(":");
+    if (colonIdx === -1) return null;
+    const prop = decl.slice(0, colonIdx).trim();
+    const value = decl.slice(colonIdx + 1).trim();
+    const camelProp = prop.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+    const escapedValue = value.replace(/'/g, "\\'");
+    return `${camelProp}: '${escapedValue}'`;
+  }).filter((e) => e !== null);
+  return `{{ ${entries.join(", ")} }}`;
+}
+export {
+  htmlToJsx
+};

package/dist/libs/instance-factories/applications/templates/react-starter/list-body-composer.js

@@ -0,0 +1,46 @@
+import { createUniversalTailwindAdapter } from "@specverse/runtime/views/tailwind";
+import { inferFieldsFromSchema } from "@specverse/runtime/views/core";
+import { htmlToJsx } from "./html-to-jsx.js";
+const TBODY_SENTINEL = "__SPECVERSE_TBODY_ROWS__";
+function composeListBody(context) {
+  const columns = inferColumns(context);
+  const headers = columns.map(humanize);
+  const adapter = createUniversalTailwindAdapter({ darkMode: true });
+  const shellHtml = adapter.components.table.render({
+    properties: { columns: headers },
+    children: TBODY_SENTINEL
+  });
+  const shellJsx = htmlToJsx(shellHtml);
+  const rowMap = buildRowMap(columns);
+  if (!shellJsx.includes(TBODY_SENTINEL)) {
+    throw new Error(
+      "composeListBody: tbody sentinel not present in adapter output. The canonical Tailwind adapter may have changed its table rendering."
+    );
+  }
+  return shellJsx.replace(TBODY_SENTINEL, rowMap);
+}
+function inferColumns(context) {
+  return inferFieldsFromSchema(context.modelSchemas, context.model.name);
+}
+function humanize(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()).trim();
+}
+function buildRowMap(columns) {
+  const cells = columns.map(
+    (col) => `            <td className="px-6 py-4 text-sm text-gray-700 dark:text-gray-300">{String((item as any).${col} ?? '')}</td>`
+  ).join("\n");
+  return [
+    "{filtered.map((item, idx) => (",
+    "  <tr",
+    "    key={idx}",
+    "    onClick={() => onSelect?.(item)}",
+    '    className="hover:bg-gray-50 dark:hover:bg-gray-800 cursor-pointer"',
+    "  >",
+    cells,
+    "  </tr>",
+    "))}"
+  ].join("\n");
+}
+export {
+  composeListBody
+};

package/dist/libs/instance-factories/applications/templates/react-starter/orchestrator.js

@@ -0,0 +1,30 @@
+import { generate as generateViews } from "./views-generator.js";
+import { generate as generateAppTsx } from "./app-tsx-generator.js";
+import { generate as generatePackageJson } from "./package-json-generator.js";
+import {
+  loadHashManifest,
+  reconcileWrites,
+  summarize,
+  HASHES_DIR,
+  HASHES_FILE
+} from "./regen-safety.js";
+async function generate(context) {
+  const { spec, projectRoot } = context;
+  const proposed = {};
+  const viewFiles = await generateViews({ spec });
+  Object.assign(proposed, viewFiles);
+  proposed["src/App.tsx"] = await generateAppTsx({ spec });
+  proposed["package.json"] = await generatePackageJson({ spec });
+  const prevManifest = loadHashManifest(projectRoot);
+  const result = reconcileWrites(projectRoot, proposed, prevManifest);
+  console.log(summarize(result, projectRoot));
+  const manifestPath = `${HASHES_DIR}/${HASHES_FILE}`;
+  const out = {
+    ...result.approvedWrites,
+    [manifestPath]: JSON.stringify(result.manifest, null, 2) + "\n"
+  };
+  return out;
+}
+export {
+  generate
+};

package/dist/libs/instance-factories/applications/templates/react-starter/package-json-generator.js

@@ -0,0 +1,38 @@
+async function generate(context) {
+  const appName = context.spec?.metadata?.name ?? context.spec?.name ?? "specverse-starter-app";
+  const packageName = slugify(appName);
+  const pkg = {
+    name: packageName,
+    private: true,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "tsc && vite build",
+      preview: "vite preview",
+      typecheck: "tsc --noEmit"
+    },
+    dependencies: {
+      react: "^18.2.0",
+      "react-dom": "^18.2.0",
+      "@tanstack/react-query": "^5.0.0"
+    },
+    devDependencies: {
+      "@types/react": "^18.2.0",
+      "@types/react-dom": "^18.2.0",
+      "@vitejs/plugin-react": "^4.2.0",
+      autoprefixer: "^10.4.20",
+      postcss: "^8.4.47",
+      tailwindcss: "^3.4.13",
+      typescript: "^5.2.0",
+      vite: "^6.0.0"
+    }
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "specverse-starter-app";
+}
+export {
+  generate
+};

package/dist/libs/instance-factories/applications/templates/react-starter/regen-safety.js

@@ -0,0 +1,89 @@
+import { createHash } from "crypto";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, relative } from "path";
+const HASHES_DIR = ".specverse-gen";
+const HASHES_FILE = "hashes.json";
+function sha256(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex");
+}
+function loadHashManifest(projectRoot) {
+  const path = join(projectRoot, HASHES_DIR, HASHES_FILE);
+  if (!existsSync(path)) return {};
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const out = {};
+      for (const [k, v] of Object.entries(parsed)) {
+        if (typeof v === "string") out[k] = v;
+      }
+      return out;
+    }
+  } catch {
+  }
+  return {};
+}
+function saveHashManifest(projectRoot, manifest) {
+  const dir = join(projectRoot, HASHES_DIR);
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, HASHES_FILE);
+  writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+}
+function reconcileWrites(projectRoot, proposed, prevManifest) {
+  const manifest = { ...prevManifest };
+  const approvedWrites = {};
+  const skipped = [];
+  for (const [relPath, content] of Object.entries(proposed)) {
+    const abs = join(projectRoot, relPath);
+    const newHash = sha256(content);
+    if (!existsSync(abs)) {
+      approvedWrites[relPath] = content;
+      manifest[relPath] = newHash;
+      continue;
+    }
+    const currentContent = readFileSync(abs, "utf8");
+    const currentHash = sha256(currentContent);
+    const recordedHash = prevManifest[relPath];
+    if (recordedHash == null) {
+      skipped.push({
+        path: relPath,
+        reason: "no prior hash recorded \u2014 cannot confirm this file was generated by us"
+      });
+      continue;
+    }
+    if (currentHash === recordedHash) {
+      approvedWrites[relPath] = content;
+      manifest[relPath] = newHash;
+      continue;
+    }
+    skipped.push({
+      path: relPath,
+      reason: "file has been edited since last generation"
+    });
+  }
+  return { approvedWrites, skipped, manifest };
+}
+function summarize(result, projectRoot) {
+  const lines = [];
+  const writeCount = Object.keys(result.approvedWrites).length;
+  lines.push(`[ReactAppStarter] Approved ${writeCount} file(s) for writing.`);
+  if (result.skipped.length > 0) {
+    lines.push(`[ReactAppStarter] Skipped ${result.skipped.length} user-edited file(s):`);
+    for (const { path, reason } of result.skipped) {
+      lines.push(`  - ${path} (${reason})`);
+    }
+    lines.push(
+      `To accept upstream regeneration for a skipped file, delete it (\`rm ${relative(process.cwd(), projectRoot)}/PATH\`) and re-run \`spv realize\`.`
+    );
+  }
+  return lines.join("\n");
+}
+export {
+  HASHES_DIR,
+  HASHES_FILE,
+  loadHashManifest,
+  reconcileWrites,
+  saveHashManifest,
+  sha256,
+  summarize
+};

package/dist/libs/instance-factories/applications/templates/react-starter/view-emitter.js

@@ -0,0 +1,56 @@
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+function emitView(context) {
+  const skeleton = loadSkeleton(context.view.type);
+  const bodyJsx = context.renderBody(context);
+  const substitutions = buildSubstitutions(context, bodyJsx);
+  return applySubstitutions(skeleton, substitutions);
+}
+const SKELETON_BY_VIEW_TYPE = {
+  list: "list.tsx.template",
+  detail: "detail.tsx.template",
+  form: "form.tsx.template",
+  dashboard: "dashboard.tsx.template"
+  // Specialist types (board, timeline, calendar, analytics, workflow,
+  // wizard, comparison, settings, map, feed, profile) come online in
+  // Phase 2e.
+};
+function loadSkeleton(viewType) {
+  const filename = SKELETON_BY_VIEW_TYPE[viewType.toLowerCase()];
+  if (!filename) {
+    throw new Error(
+      `No skeleton registered for view type "${viewType}". Known types: ${Object.keys(SKELETON_BY_VIEW_TYPE).join(", ")}.`
+    );
+  }
+  const here = dirname(fileURLToPath(import.meta.url));
+  const path = join(here, "skeletons", filename);
+  return readFileSync(path, "utf8");
+}
+function buildSubstitutions(context, body) {
+  const modelName = context.model.name;
+  const pluralModel = pluralize(modelName);
+  return {
+    MODEL_NAME: modelName,
+    PLURAL_MODEL: pluralModel,
+    PLURAL_LOWER: pluralModel.toLowerCase(),
+    SINGULAR_LOWER: modelName.toLowerCase(),
+    BODY: body
+  };
+}
+function applySubstitutions(template, subs) {
+  let out = template;
+  for (const [key, value] of Object.entries(subs)) {
+    const pattern = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+    out = out.replace(pattern, value);
+  }
+  return out;
+}
+function pluralize(s) {
+  if (/[^aeiou]y$/i.test(s)) return s.slice(0, -1) + "ies";
+  if (/(s|x|z|ch|sh)$/i.test(s)) return s + "es";
+  return s + "s";
+}
+export {
+  emitView
+};