superdev-cli 0.1.0

package/src/features/acceptance.mjs

@@ -0,0 +1,315 @@
+// The spec-depth gate. Brief section 9.2.
+//
+// Depth comes from risk, and it is a promise about how much of the contract is
+// written down before anyone builds against it. A feature marked `full` that
+// carries microspec content is worse than one honestly marked `microspec`,
+// because the depth is what a reader trusts when deciding whether to ask more
+// questions.
+//
+// So depth is checked at the one moment it matters: acceptance. Before that a
+// feature is a draft and may be as thin as it likes.
+
+import { mutate, query, setStatus, currentProject, json, DbError } from "../db/store.mjs";
+import { DEPTH_REQUIREMENTS, SPEC_DEPTHS } from "../model/vocabulary.mjs";
+
+export const E = {
+  NOT_FOUND: "E_FEATURE_NOT_FOUND",
+  DEPTH_UNMET: "E_SPEC_DEPTH_UNMET",
+  UNKNOWN_DEPTH: "E_UNKNOWN_SPEC_DEPTH",
+};
+
+/**
+ * What each requirement means, in the words used when one is missing, plus how
+ * to satisfy it. The check is deliberately shallow: it asks whether the record
+ * exists, never whether it is any good. Judging quality is a person's job and
+ * pretending otherwise would make the gate a nuisance rather than a help.
+ */
+const CHECKS = {
+  purpose: {
+    says: "what this feature is for",
+    fix: "Set the feature's purpose.",
+    met: (s) => Boolean(s.feature.purpose?.trim()),
+  },
+  user_statement: {
+    says: "who wants it and what they are trying to do",
+    fix: "Set the feature's user statement.",
+    met: (s) => Boolean(s.feature.user_statement?.trim()),
+  },
+  scope: {
+    says: "what is in scope and what is deliberately out",
+    fix: "Record at least one in-scope and one out-of-scope item.",
+    met: (s) => json(s.feature.scope_in_json, []).length > 0 && json(s.feature.scope_out_json, []).length > 0,
+  },
+  flow: {
+    says: "the primary flow, step by step",
+    fix: "Record the numbered primary flow.",
+    met: (s) => s.flows.length > 0,
+  },
+  acceptance_criteria: {
+    says: "how anyone can tell it works",
+    fix: "Record at least one acceptance criterion with a verification method.",
+    met: (s) => s.criteria.length > 0,
+  },
+  edge_cases: {
+    says: "what happens when things go wrong",
+    fix: "Walk the edge-case categories, marking each one specified or not applicable with a reason.",
+    met: (s) => s.edgeCases.length > 0,
+  },
+  surfaces: {
+    says: "the surfaces and actions a person touches",
+    fix: "Record the surfaces this feature owns, or record an edge case in the platform_variance category saying it has no interface.",
+    met: (s) =>
+      s.surfaces.length > 0 || s.edgeCases.some((e) => e.category === "platform_variance"),
+  },
+  api_or_data: {
+    says: "the API operations or data entities behind it",
+    fix: "Record an API operation or a data entity.",
+    met: (s) => s.apis.length > 0 || s.entities.length > 0,
+  },
+  workflow: {
+    says: "the workflow and its steps",
+    fix: "Record a workflow with its ordered steps.",
+    met: (s) => s.workflows.length > 0 && s.steps.length > 0,
+  },
+  observability: {
+    says: "the signals that prove it works in the open",
+    fix: "Record an observability requirement, or set the workflow's observability.",
+    met: (s) =>
+      s.nfrs.some((n) => /observab|monitor|telemetry|logging|alert/i.test(n.category ?? "")) ||
+      s.workflows.some((w) => Boolean(w.observability?.trim())),
+  },
+  test_plan: {
+    says: "how it will be tested",
+    fix: "Give each acceptance criterion a verification method, or record the module test plan.",
+    met: (s) => s.criteria.length > 0 && s.criteria.every((c) => Boolean(c.verification_method?.trim())),
+  },
+  decision: {
+    says: "the decision that governs the load-bearing choice",
+    fix: "Record a decision scoped to this feature.",
+    met: (s) => s.decisions.length > 0,
+  },
+  migration_or_rollback: {
+    says: "how the data moves and how the release is undone",
+    fix: "Give every schema migration a rollback plan, or record an edge case in the data_migration_states category saying why none applies.",
+    // Every migration needs its rollback, not just one of them, and a feature
+    // that changes no schema says so deliberately rather than by silence.
+    met: (s) =>
+      (s.migrations.length > 0 && s.migrations.every((m) => Boolean(m.rollback_plan?.trim()))) ||
+      s.edgeCases.some((e) => e.category === "data_migration_states"),
+  },
+  security_privacy: {
+    says: "the security and privacy analysis",
+    fix: "Record a security or privacy requirement for this feature.",
+    met: (s) => s.nfrs.some((n) => /secur|privac|complian/i.test(n.category ?? "")),
+  },
+};
+
+async function gather(db, featureId) {
+  const feature = await db.get("SELECT * FROM features WHERE id = ?", featureId);
+  if (!feature) throw new DbError(E.NOT_FOUND, `There is no feature ${featureId}.`);
+  const all = (sql, ...p) => db.all(sql, ...p);
+  const workflows = await all("SELECT * FROM workflows WHERE feature_id = ?", featureId);
+  const steps = workflows.length
+    ? await all(
+        `SELECT * FROM workflow_steps WHERE workflow_id IN (${workflows.map(() => "?").join(",")})`,
+        ...workflows.map((w) => w.id),
+      )
+    : [];
+  return {
+    feature,
+    flows: await all("SELECT * FROM feature_flows WHERE feature_id = ?", featureId),
+    criteria: await all("SELECT * FROM feature_acceptance_criteria WHERE feature_id = ?", featureId),
+    edgeCases: await all("SELECT * FROM feature_edge_cases WHERE feature_id = ?", featureId),
+    surfaces: await all("SELECT * FROM surfaces WHERE feature_id = ?", featureId),
+    apis: await all("SELECT * FROM api_operations WHERE feature_id = ?", featureId),
+    entities: await all("SELECT * FROM data_entities WHERE feature_id = ?", featureId),
+    workflows,
+    steps,
+    nfrs: await all("SELECT * FROM non_functional_requirements WHERE feature_id = ?", featureId),
+    migrations: await all("SELECT * FROM schema_migrations WHERE feature_id = ?", featureId),
+    decisions: await all(
+      `SELECT d.* FROM decisions d
+        WHERE (d.scope_type = 'feature' AND d.scope_id = ?)
+           OR EXISTS (SELECT 1 FROM decision_links l
+                       WHERE l.decision_id = d.id AND l.target_type = 'feature' AND l.target_id = ?)`,
+      featureId, featureId,
+    ),
+  };
+}
+
+/** What the declared depth requires, and which parts are present. */
+export async function depthReadiness(db, featureId) {
+  const state = await gather(db, featureId);
+  const depth = String(state.feature.spec_depth ?? "standard");
+  const required = DEPTH_REQUIREMENTS[depth];
+  if (!required) {
+    throw new DbError(E.UNKNOWN_DEPTH, `"${depth}" is not a spec depth. Use one of: ${SPEC_DEPTHS.join(", ")}.`);
+  }
+  const components = required.map((key) => {
+    const check = CHECKS[key];
+    return {
+      requirement: key,
+      says: check.says,
+      met: Boolean(check.met(state)),
+      fix: check.fix,
+    };
+  });
+  const missing = components.filter((c) => !c.met);
+  return {
+    featureId,
+    name: state.feature.name,
+    depth,
+    status: state.feature.status,
+    required: components.length,
+    met: components.length - missing.length,
+    components,
+    missing,
+    acceptable: missing.length === 0,
+  };
+}
+
+/**
+ * Accept a feature, refusing while its declared depth is unmet.
+ *
+ * The refusal names every missing part at once rather than one at a time: being
+ * sent back four times in a row for four separate reasons is how a gate teaches
+ * people to route around it.
+ */
+export async function acceptFeature(root, featureId, { apply = false, actor = "superdev" } = {}) {
+  const report = await query(root, (db) => depthReadiness(db, featureId));
+
+  if (!report.acceptable) {
+    throw new DbError(
+      E.DEPTH_UNMET,
+      `${report.name} is declared ${report.depth} depth, and ${report.missing.length} of the ${report.required} things that depth promises are missing: ` +
+        report.missing.map((m) => m.says).join("; ") +
+        `. Record them, or lower the depth to match what this feature actually is.`,
+      { featureId, depth: report.depth, missing: report.missing },
+    );
+  }
+
+  if (!apply) return { ...report, applied: false };
+
+  await mutate(root, async (db) => {
+    // Re-checked inside the transaction that accepts. Reading the gate on one
+    // connection and applying on another leaves a window where the rows that
+    // satisfied it can disappear between the two.
+    const confirmed = await depthReadiness(db, featureId);
+    if (!confirmed.acceptable) {
+      throw new DbError(
+        E.DEPTH_UNMET,
+        `${confirmed.name} changed while it was being accepted and no longer carries what ${confirmed.depth} depth promises: ${confirmed.missing.map((x) => x.says).join("; ")}.`,
+        { featureId, missing: confirmed.missing },
+      );
+    }
+    const project = await currentProject(db);
+    await setStatus(db, "feature", featureId, "accepted", {
+      projectId: project?.id,
+      actor,
+      note: `Accepted at ${report.depth} depth with all ${report.required} requirements recorded`,
+      activityType: "specification_changed",
+      activitySummary: `Accepted ${report.name} at ${report.depth} depth`,
+    });
+  });
+  return { ...report, status: "accepted", applied: true };
+}
+
+/** Every feature whose recorded depth is not backed by what it carries. */
+export async function depthGaps(root) {
+  return query(root, async (db) => {
+    const features = await db.all("SELECT id FROM features ORDER BY id");
+    const out = [];
+    for (const { id } of features) {
+      const report = await depthReadiness(db, id);
+      // A draft is allowed to be thin. Anything already accepted is claiming
+      // its depth is real, so a gap there is a live inaccuracy.
+      if (!report.acceptable && report.status === "accepted") out.push(report);
+    }
+    return out;
+  });
+}
+
+// --------------------------------------------------------------- completion
+
+/**
+ * Whether a feature's contract is satisfied, and what is missing when it is not.
+ *
+ * Section 6.3 says completion is derived, never asserted. This is the
+ * derivation: every acceptance criterion under the feature is met or waived
+ * with a reason, and every task against it is finished or deliberately stopped.
+ * Nothing here reads the feature's own status, because that column is the thing
+ * being decided rather than evidence about it.
+ */
+export async function completionReadiness(db, featureId) {
+  const feature = await db.get("SELECT * FROM features WHERE id = ?", featureId);
+  if (!feature) throw new DbError(E.NOT_FOUND, `There is no feature ${featureId}.`);
+
+  const criteria = await db.all(
+    "SELECT id, criterion, status FROM feature_acceptance_criteria WHERE feature_id = ?", featureId);
+  const tasks = await db.all(
+    "SELECT id, name, status FROM tasks WHERE feature_id = ?", featureId);
+
+  const unmet = criteria.filter((c) => !["met", "waived"].includes(c.status));
+  const open = tasks.filter((t) => !["complete", "cancelled", "superseded"].includes(t.status));
+
+  const missing = [
+    criteria.length === 0
+      ? { says: "no acceptance criterion, so nothing states what finishing it would mean", fix: `Record one with superdev feature specify ${featureId} --criterion.` }
+      : null,
+    unmet.length
+      ? { says: `${unmet.length} acceptance criteria not yet met: ${unmet.map((c) => c.id).join(", ")}`,
+          fix: `Attach passing evidence with superdev task evidence <task> --criterion, or waive one with superdev feature waive <AC-id> --reason.` }
+      : null,
+    open.length
+      ? { says: `${open.length} tasks still open: ${open.map((t) => `${t.id} (${t.status})`).join(", ")}`,
+          fix: "Complete or cancel them." }
+      : null,
+  ].filter(Boolean);
+
+  return {
+    featureId, name: feature.name, status: feature.status,
+    criteria: criteria.length, tasks: tasks.length,
+    complete: missing.length === 0,
+    missing,
+  };
+}
+
+/**
+ * Move a feature to complete, and only ever because its contract says so.
+ *
+ * This exists because nothing did. A feature could be accepted and never
+ * finished: `setStatus` was called for `accepted` and for nothing else, so the
+ * only way a feature ever reached complete was a direct update that left no
+ * history, which is precisely what section 7.4 forbids and what this module is
+ * otherwise careful about. Eighty seven features carried a completion nobody
+ * recorded, and four that genuinely were finished sat at accepted because there
+ * was no way to say so.
+ */
+export async function completeFeature(root, featureId, { apply = false, actor = "superdev" } = {}) {
+  const report = await query(root, (db) => completionReadiness(db, featureId));
+  if (!report.complete) {
+    throw new DbError(E.DEPTH_UNMET,
+      `${report.name} is not finished: ${report.missing.map((m) => m.says).join("; ")}.`,
+      { featureId, missing: report.missing });
+  }
+  if (report.status === "complete") return { ...report, applied: false, unchanged: true };
+  if (!apply) return { ...report, applied: false };
+
+  await mutate(root, async (db) => {
+    const confirmed = await completionReadiness(db, featureId);
+    if (!confirmed.complete) {
+      throw new DbError(E.DEPTH_UNMET,
+        `${confirmed.name} changed while it was being completed: ${confirmed.missing.map((m) => m.says).join("; ")}.`,
+        { featureId });
+    }
+    const project = await currentProject(db);
+    await setStatus(db, "feature", featureId, "complete", {
+      projectId: project?.id,
+      actor,
+      note: `Every one of its ${confirmed.criteria} acceptance criteria is met or waived and all ${confirmed.tasks} tasks are finished`,
+      activityType: "specification_changed",
+      activitySummary: `${confirmed.name} is complete: its contract is satisfied`,
+    });
+  });
+  return { ...report, status: "complete", applied: true };
+}

package/src/features/specify.mjs

@@ -0,0 +1,248 @@
+// Write a feature's specification.
+//
+// The depth gate refuses to accept a feature until it carries what its depth
+// promises, and `feature depth` says exactly what is missing and how to close
+// it. Nothing could close it. Every fix line named a database record, and no
+// command wrote one, so a feature drafted by init stayed at purpose only and
+// could never be accepted. The feature skill's step 8 says to fill the
+// contracts the depth requires, and was not a thing anyone could do.
+//
+// This writes the six microspec covers, which is what stands between a drafted
+// feature and an acceptable one: purpose, who wants it, what is in and out of
+// scope, the primary flow, the acceptance criteria and the edge cases. Deeper
+// covers hang off records that already have their own commands and their own
+// homes, and are not duplicated here.
+//
+// Repeated values replace rather than accumulate. Specifying a flow twice means
+// the flow was rewritten, not that the feature now has two of them.
+
+import { create, mutate, json } from "../db/store.mjs";
+import { EDGE_CASE_CATEGORIES } from "../model/vocabulary.mjs";
+import { sanitizeExternal } from "../model/screening.mjs";
+
+export const E = {
+  NOT_FOUND: "E_FEATURE_NOT_FOUND",
+  UNKNOWN_CATEGORY: "E_UNKNOWN_EDGE_CATEGORY",
+  NOT_SPECIFIABLE: "E_FEATURE_NOT_SPECIFIABLE",
+  NOTHING_GIVEN: "E_NOTHING_TO_SPECIFY",
+};
+
+export class SpecError extends Error {
+  constructor(code, message, detail) {
+    super(message);
+    this.name = "SpecError";
+    this.code = code;
+    if (detail !== undefined) this.detail = detail;
+  }
+}
+
+const clean = (value, max = 600) => {
+  const text = sanitizeExternal(String(value ?? "")).replace(/\s+/g, " ").trim();
+  return text ? text.slice(0, max) : null;
+};
+
+/**
+ * Apply a specification to a feature.
+ *
+ * Everything is one transaction, so a specification that fails halfway leaves
+ * the feature as it was rather than half rewritten.
+ */
+export async function specifyFeature(root, featureId, input = {}, { actor = "superdev", sessionId = null, apply = false } = {}) {
+  const {
+    purpose = null, userStatement = null, scopeIn = [], scopeOut = [],
+    flow = [], criteria = [], edgeCases = [],
+  } = input;
+
+  const given = [
+    purpose, userStatement,
+    scopeIn.length ? scopeIn : null, scopeOut.length ? scopeOut : null,
+    flow.length ? flow : null, criteria.length ? criteria : null,
+    edgeCases.length ? edgeCases : null,
+  ].filter(Boolean);
+  if (!given.length) {
+    throw new SpecError(E.NOTHING_GIVEN,
+      "Nothing to specify. Pass at least one of --purpose, --user, --in, --out, --flow, --criterion or --edge.");
+  }
+
+  for (const edge of edgeCases) {
+    if (!EDGE_CASE_CATEGORIES.includes(edge.category)) {
+      throw new SpecError(E.UNKNOWN_CATEGORY,
+        `${edge.category} is not an edge-case category. The list is fixed so a reader can walk it: ${EDGE_CASE_CATEGORIES.join(", ")}.`);
+    }
+  }
+
+  const summary = {
+    featureId,
+    purpose: Boolean(purpose),
+    userStatement: Boolean(userStatement),
+    scopeIn: scopeIn.length,
+    scopeOut: scopeOut.length,
+    flow: flow.length,
+    criteria: criteria.length,
+    edgeCases: edgeCases.length,
+  };
+  if (!apply) return { applied: false, ...summary };
+
+  return mutate(root, async (db) => {
+    const feature = await db.get("SELECT * FROM features WHERE id = ?", featureId);
+    if (!feature) throw new SpecError(E.NOT_FOUND, `There is no feature ${featureId}. Run superdev feature list to see them.`);
+    // An accepted feature is a contract others have linked work to. Changing it
+    // is a Change, recorded through the change surface, not an edit.
+    if (feature.status === "accepted" || feature.status === "complete") {
+      throw new SpecError(E.NOT_SPECIFIABLE,
+        `${featureId} is ${feature.status} and tasks may already implement it. Record what is moving with superdev change record, then specify it again.`);
+    }
+
+    const meta = (text) => ({
+      projectId: feature.project_id, actor, sessionId,
+      activityType: "specification_changed", activitySummary: clean(text, 200),
+    });
+
+    const fields = {};
+    if (purpose) fields.purpose = clean(purpose, 1000);
+    if (userStatement) fields.user_statement = clean(userStatement, 1000);
+    if (scopeIn.length) fields.scope_in_json = JSON.stringify(scopeIn.map((x) => clean(x, 300)).filter(Boolean));
+    if (scopeOut.length) fields.scope_out_json = JSON.stringify(scopeOut.map((x) => clean(x, 300)).filter(Boolean));
+    if (Object.keys(fields).length) {
+      const sets = Object.keys(fields).map((k) => `${k} = ?`).join(", ");
+      await db.run(`UPDATE features SET ${sets} WHERE id = ?`, ...Object.values(fields), featureId);
+    }
+
+    if (flow.length) {
+      await db.run("DELETE FROM feature_flows WHERE feature_id = ?", featureId);
+      for (const [index, step] of flow.entries()) {
+        await create(db, "feature_flow", {
+          feature_id: featureId, sequence: index + 1, step: clean(step, 400),
+        }, meta(`Primary flow recorded for ${featureId}`));
+      }
+    }
+
+    if (criteria.length) {
+      // Criteria already carrying evidence are left alone: deleting one would
+      // orphan the proof that it was met.
+      const proven = await db.all(
+        "SELECT id, criterion FROM feature_acceptance_criteria WHERE feature_id = ? AND evidence_id IS NOT NULL",
+        featureId,
+      );
+      const keep = new Set(proven.map((c) => c.criterion));
+      await db.run(
+        "DELETE FROM feature_acceptance_criteria WHERE feature_id = ? AND evidence_id IS NULL",
+        featureId,
+      );
+      let sequence = proven.length;
+      for (const criterion of criteria) {
+        const text = clean(criterion.criterion ?? criterion, 500);
+        if (!text || keep.has(text)) continue;
+        sequence += 1;
+        await create(db, "feature_acceptance_criterion", {
+          feature_id: featureId,
+          criterion: text,
+          verification_method: clean(criterion.verification ?? "Checked by hand against the running product.", 300),
+          status: "unmet",
+          sequence,
+        }, meta(`Acceptance criterion recorded for ${featureId}`));
+      }
+    }
+
+    if (edgeCases.length) {
+      for (const edge of edgeCases) {
+        const notApplicable = edge.applicability === "not_applicable";
+        const behavior = clean(edge.behavior, 500);
+        // One row per category, so specifying the same category twice is the
+        // same question answered again rather than asked twice.
+        await db.run(
+          "DELETE FROM feature_edge_cases WHERE feature_id = ? AND category = ?",
+          featureId, edge.category,
+        );
+        await create(db, "feature_edge_case", {
+          feature_id: featureId,
+          category: edge.category,
+          applicability: notApplicable ? "not_applicable" : "applicable",
+          behavior: notApplicable ? null : behavior,
+          reason_not_applicable: notApplicable ? behavior : null,
+        }, meta(`Edge case recorded for ${featureId}: ${edge.category}`));
+      }
+    }
+
+    const after = await db.get("SELECT * FROM features WHERE id = ?", featureId);
+    return {
+      applied: true,
+      ...summary,
+      feature: {
+        id: after.id,
+        name: after.name,
+        status: after.status,
+        depth: after.spec_depth,
+        scopeIn: json(after.scope_in_json, []).length,
+        scopeOut: json(after.scope_out_json, []).length,
+      },
+    };
+  });
+}
+
+/** Declare how much specification this feature owes before it can be accepted. */
+export async function setDepth(root, featureId, depth, { actor = "superdev", apply = false } = {}) {
+  const { SPEC_DEPTHS } = await import("../model/vocabulary.mjs");
+  if (!SPEC_DEPTHS.includes(depth)) {
+    throw new SpecError(E.NOT_SPECIFIABLE,
+      `${depth} is not a specification depth. Section 9.2 names three: ${SPEC_DEPTHS.join(", ")}.`);
+  }
+  return mutate(root, async (db) => {
+    const feature = await db.get("SELECT * FROM features WHERE id = ?", featureId);
+    if (!feature) throw new SpecError(E.NOT_FOUND, `There is no feature ${featureId}.`);
+    if (feature.spec_depth === depth) {
+      return { applied: false, unchanged: true, featureId, depth, name: feature.name };
+    }
+    if (!apply) {
+      return { applied: false, featureId, name: feature.name, from: feature.spec_depth, depth };
+    }
+    await db.run("UPDATE features SET spec_depth = ? WHERE id = ?", depth, featureId);
+    return { applied: true, featureId, name: feature.name, from: feature.spec_depth, depth };
+  });
+}
+
+/**
+ * Set an acceptance criterion aside, with the reason on the record.
+ *
+ * The schema has carried a waived status since the first migration and nothing
+ * could set it, while two refusals told the reader to waive a criterion. A
+ * status no command can reach is the same as no status at all, except that it
+ * makes the refusal a dead end.
+ *
+ * The reason is required. A waived criterion with no reason is indistinguishable
+ * from one somebody quietly gave up on, which is the thing evidence gating
+ * exists to prevent.
+ */
+export async function waiveCriterion(root, criterionId, { reason, actor = "superdev", sessionId = null, apply = false } = {}) {
+  const text = clean(reason, 500);
+  if (!text) {
+    throw new SpecError(E.NOTHING_GIVEN,
+      "Say why this criterion is being set aside. A waiver without a reason reads the same as forgetting.");
+  }
+  return mutate(root, async (db) => {
+    const criterion = await db.get("SELECT * FROM feature_acceptance_criteria WHERE id = ?", criterionId);
+    if (!criterion) throw new SpecError(E.NOT_FOUND, `There is no acceptance criterion ${criterionId}.`);
+    if (criterion.status === "met") {
+      throw new SpecError(E.NOT_SPECIFIABLE,
+        `${criterionId} is already met, so there is nothing to waive. Retract the evidence first if it should not be.`);
+    }
+    const feature = await db.get("SELECT id, project_id, name FROM features WHERE id = ?", criterion.feature_id);
+    if (!apply) {
+      return { applied: false, criterionId, criterion: criterion.criterion, feature: feature?.id ?? null, reason: text };
+    }
+    await db.run(
+      "UPDATE feature_acceptance_criteria SET status = 'waived', waiver_reason = ? WHERE id = ?",
+      text, criterionId,
+    );
+    const { recordActivity } = await import("../db/store.mjs");
+    await recordActivity(db, feature.project_id, {
+      type: "specification_changed",
+      actor,
+      sessionId,
+      featureId: feature.id,
+      summary: `${criterionId} waived on ${feature.name}: ${text}`.slice(0, 200),
+      metadata: { criterion: criterionId, reason: text },
+    });
+    return { applied: true, criterionId, criterion: criterion.criterion, feature: feature.id, reason: text };
+  });
+}