@meetless/mla 0.1.4

package/dist/lib/rules/interception-store.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertToolAttempt = insertToolAttempt;
+exports.getToolAttempt = getToolAttempt;
+exports.advanceDenyEmissionToResponseEmitted = advanceDenyEmissionToResponseEmitted;
+exports.countDenyDecisionsAwaitingEmission = countDenyDecisionsAwaitingEmission;
+exports.countFailOpenEnforcementViolations = countFailOpenEnforcementViolations;
+exports.insertRuleEvaluationRecord = insertRuleEvaluationRecord;
+exports.getRuleEvaluationRecord = getRuleEvaluationRecord;
+exports.listEvaluationsForAttempt = listEvaluationsForAttempt;
+exports.listObservedRulesInScope = listObservedRulesInScope;
+exports.resolveObservedSnapshotInScope = resolveObservedSnapshotInScope;
+// ---------------------------------------------------------------------------
+// tool_attempt
+// ---------------------------------------------------------------------------
+function insertToolAttempt(store, rec) {
+    store.db
+        .prepare(`INSERT INTO tool_attempt
+        (attempt_id, runtime_scope_id, session_id, tool_name, evaluation_input_snapshot,
+         evaluation_input_hash, aggregate_decision, deny_emission_status,
+         input_authority_config_hash, created_at)
+       VALUES
+        (@attempt_id, @runtime_scope_id, @session_id, @tool_name, @evaluation_input_snapshot,
+         @evaluation_input_hash, @aggregate_decision, @deny_emission_status,
+         @input_authority_config_hash, @created_at)`)
+        .run({
+        attempt_id: rec.attemptId,
+        runtime_scope_id: rec.runtimeScopeId,
+        session_id: rec.sessionId,
+        tool_name: rec.toolName,
+        evaluation_input_snapshot: rec.evaluationInputSnapshot,
+        evaluation_input_hash: rec.evaluationInputHash,
+        aggregate_decision: rec.aggregateDecision,
+        deny_emission_status: rec.denyEmissionStatus,
+        input_authority_config_hash: rec.inputAuthorityConfigHash,
+        created_at: rec.createdAt,
+    });
+}
+function mapAttemptRow(row) {
+    return {
+        attemptId: row.attempt_id,
+        runtimeScopeId: row.runtime_scope_id,
+        sessionId: row.session_id,
+        toolName: row.tool_name,
+        evaluationInputSnapshot: row.evaluation_input_snapshot,
+        evaluationInputHash: row.evaluation_input_hash,
+        aggregateDecision: row.aggregate_decision,
+        denyEmissionStatus: row.deny_emission_status,
+        inputAuthorityConfigHash: row.input_authority_config_hash ?? null,
+        createdAt: row.created_at,
+    };
+}
+function getToolAttempt(store, attemptId) {
+    const row = store.db
+        .prepare(`SELECT * FROM tool_attempt WHERE attempt_id = ?`)
+        .get(attemptId);
+    if (!row)
+        return null;
+    return mapAttemptRow(row);
+}
+/**
+ * Advance a committed deny from DECISION_RECORDED to RESPONSE_EMITTED, the SINGLE mutation
+ * trg_attempt_frozen permits on tool_attempt (interception-schema.ts). The deny pilot (slice 10)
+ * persists the DECISION_RECORDED row and COMMITS it BEFORE emitting the deny response, then calls this
+ * to mark the response emitted. A crash between the deny commit and this advance therefore leaves an
+ * honest DECISION_RECORDED row (recoverable, never NO_DECISION) per R1-4. The WHERE clause touches ONLY
+ * a row still held at DENY / DECISION_RECORDED, so it changes nothing but deny_emission_status (the
+ * trigger's one allowed delta) and a re-run or a wrong-state row is a harmless no-op, never an abort.
+ */
+function advanceDenyEmissionToResponseEmitted(store, attemptId) {
+    store.db
+        .prepare(`UPDATE tool_attempt
+          SET deny_emission_status = 'RESPONSE_EMITTED'
+        WHERE attempt_id = ?
+          AND aggregate_decision = 'DENY'
+          AND deny_emission_status = 'DECISION_RECORDED'`)
+        .run(attemptId);
+}
+/**
+ * Count the committed denies still held at DECISION_RECORDED: a deny whose decision was committed but
+ * whose response was never advanced to RESPONSE_EMITTED. These are the honest crash-window leftovers of
+ * the deny pilot (a crash between the deny commit and advanceDenyEmissionToResponseEmitted), recoverable
+ * and never lost (R1-4). `mla doctor` surfaces this count (P0.60 honest deny-emission accounting) so an
+ * operator can see whether the hook is recording denials it never emitted; a non-zero count is honest,
+ * not corruption, so it never goes RED.
+ */
+function countDenyDecisionsAwaitingEmission(store) {
+    const row = store.db
+        .prepare(`SELECT COUNT(*) AS n
+         FROM tool_attempt
+        WHERE aggregate_decision = 'DENY'
+          AND deny_emission_status = 'DECISION_RECORDED'`)
+        .get();
+    return row.n;
+}
+/**
+ * Count the violations that ALREADY failed open: a VIOLATION whose effective enforcement degraded to NONE
+ * because a deny-admission gate fired (RULE_ENFORCEMENT_UNAVAILABLE, decision 5). Unlike a crash-window
+ * emission leftover, this is NOT recoverable: the prohibited action already passed un-governed. A version
+ * arm only reaches effective NONE on a gated DENY, and an observed arm always enforces OBSERVE, so
+ * (result = VIOLATION AND effective_enforcement = NONE) is exactly the historical fail-open set (the same
+ * condition the `mla rules activity` enforcementUnavailable column reports). `mla doctor` surfaces this
+ * count so an operator can confirm at a glance whether enforcement has ever silently missed on this box.
+ */
+function countFailOpenEnforcementViolations(store) {
+    const row = store.db
+        .prepare(`SELECT COUNT(*) AS n
+         FROM rule_evaluation_record
+        WHERE result = 'VIOLATION'
+          AND effective_enforcement = 'NONE'`)
+        .get();
+    return row.n;
+}
+// ---------------------------------------------------------------------------
+// rule_evaluation_record
+// ---------------------------------------------------------------------------
+function insertRuleEvaluationRecord(store, rec) {
+    store.db
+        .prepare(`INSERT INTO rule_evaluation_record
+        (evaluation_id, attempt_id, runtime_scope_id, result, eligible_enforcement,
+         effective_enforcement, verdict_reason_code, gate_reason_code, evaluator_contract_version,
+         observed_rule_snapshot, observed_rule_hash, rule_version_id, canonical_payload_hash,
+         created_at)
+       VALUES
+        (@evaluation_id, @attempt_id, @runtime_scope_id, @result, @eligible_enforcement,
+         @effective_enforcement, @verdict_reason_code, @gate_reason_code, @evaluator_contract_version,
+         @observed_rule_snapshot, @observed_rule_hash, @rule_version_id, @canonical_payload_hash,
+         @created_at)`)
+        .run({
+        evaluation_id: rec.evaluationId,
+        attempt_id: rec.attemptId,
+        runtime_scope_id: rec.runtimeScopeId,
+        result: rec.result,
+        eligible_enforcement: rec.eligibleEnforcement,
+        effective_enforcement: rec.effectiveEnforcement,
+        verdict_reason_code: rec.verdictReasonCode,
+        gate_reason_code: rec.gateReasonCode,
+        evaluator_contract_version: rec.evaluatorContractVersion,
+        observed_rule_snapshot: rec.observedRuleSnapshot,
+        observed_rule_hash: rec.observedRuleHash,
+        rule_version_id: rec.ruleVersionId,
+        canonical_payload_hash: rec.canonicalPayloadHash,
+        created_at: rec.createdAt,
+    });
+}
+function mapEvaluationRow(row) {
+    return {
+        evaluationId: row.evaluation_id,
+        attemptId: row.attempt_id,
+        runtimeScopeId: row.runtime_scope_id,
+        result: row.result,
+        eligibleEnforcement: row.eligible_enforcement,
+        effectiveEnforcement: row.effective_enforcement,
+        verdictReasonCode: row.verdict_reason_code,
+        gateReasonCode: row.gate_reason_code ?? null,
+        evaluatorContractVersion: row.evaluator_contract_version,
+        observedRuleSnapshot: row.observed_rule_snapshot ?? null,
+        observedRuleHash: row.observed_rule_hash ?? null,
+        ruleVersionId: row.rule_version_id ?? null,
+        canonicalPayloadHash: row.canonical_payload_hash ?? null,
+        createdAt: row.created_at,
+    };
+}
+function getRuleEvaluationRecord(store, evaluationId) {
+    const row = store.db
+        .prepare(`SELECT * FROM rule_evaluation_record WHERE evaluation_id = ?`)
+        .get(evaluationId);
+    if (!row)
+        return null;
+    return mapEvaluationRow(row);
+}
+/** List one attempt's evaluation records, ordered by evaluation_id so a re-read is stable. */
+function listEvaluationsForAttempt(store, attemptId) {
+    const rows = store.db
+        .prepare(`SELECT * FROM rule_evaluation_record WHERE attempt_id = ? ORDER BY evaluation_id`)
+        .all(attemptId);
+    return rows.map(mapEvaluationRow);
+}
+/**
+ * List the observed rules R0 has recorded in ONE runtime scope, one row per distinct
+ * observed_rule_hash. The observed arm is identified by a non-null observed_rule_hash (the version
+ * arm carries none). For each rule it reports the latest verdict and timestamp (the newest row by
+ * created_at then evaluation_id, both descending, so a deterministic single row wins), the total
+ * observation count, and whether a LocalRuleVersion in this same scope derives from that observed
+ * hash. A pure read that NEVER crosses runtime scopes (proposal §2.3 / P0.51) and never infers a
+ * logical rule id. Rows are ordered by observed_rule_hash so the listing is stable across reads.
+ */
+function listObservedRulesInScope(store, runtimeScopeId) {
+    const rows = store.db
+        .prepare(`WITH observed AS (
+         SELECT
+           observed_rule_hash,
+           observed_rule_snapshot,
+           result,
+           created_at,
+           ROW_NUMBER() OVER (
+             PARTITION BY observed_rule_hash
+             ORDER BY created_at DESC, evaluation_id DESC
+           ) AS rn,
+           COUNT(*) OVER (PARTITION BY observed_rule_hash) AS observation_count
+         FROM rule_evaluation_record
+         WHERE runtime_scope_id = @scope
+           AND observed_rule_hash IS NOT NULL
+       )
+       SELECT
+         o.observed_rule_hash     AS observed_rule_hash,
+         o.observed_rule_snapshot AS observed_rule_snapshot,
+         o.result                 AS result,
+         o.created_at             AS created_at,
+         o.observation_count      AS observation_count,
+         EXISTS (
+           SELECT 1 FROM local_rule_version v
+           WHERE v.runtime_scope_id = @scope
+             AND v.derived_from_observed_hash = o.observed_rule_hash
+         )                        AS has_local_version
+       FROM observed o
+       WHERE o.rn = 1
+       ORDER BY o.observed_rule_hash`)
+        .all({ scope: runtimeScopeId });
+    return rows.map((row) => ({
+        observedRuleHash: row.observed_rule_hash,
+        ruleText: observedRuleText(row.observed_rule_snapshot),
+        latestResult: row.result,
+        latestObservedAt: row.created_at,
+        observationCount: row.observation_count,
+        hasLocalVersion: row.has_local_version === 1,
+    }));
+}
+/** Read the directive prose from a frozen observed-rule-v1 snapshot; "" when none is present. */
+function observedRuleText(snapshot) {
+    const parsed = JSON.parse(snapshot);
+    return typeof parsed.text === "string" ? parsed.text : "";
+}
+/**
+ * Resolve the EXACT observed-rule snapshot R0 recorded under one (runtime scope, observed hash), the
+ * read R1 attestation builds on (proposal §10.1 step 6, §2.4). It scans ONLY rule_evaluation_record
+ * rows in the given scope whose observed_rule_hash matches (the observed arm; the version arm carries
+ * a null hash), grouping by the snapshot body so byte-identical observations collapse. Cardinality is
+ * explicit and never guesses: zero groups is NOT_FOUND (nothing to attest); exactly one group is
+ * FOUND with that snapshot and the observation count; two or more DISTINCT groups under the same
+ * (scope, hash) is a COLLISION that refuses to pick one (hash corruption). It NEVER crosses a runtime
+ * scope (the WHERE pins scope) and NEVER infers a logical rule id (it returns the frozen snapshot, no
+ * rule identity).
+ */
+function resolveObservedSnapshotInScope(store, runtimeScopeId, observedRuleHash) {
+    const groups = store.db
+        .prepare(`SELECT observed_rule_snapshot AS snapshot, COUNT(*) AS n
+         FROM rule_evaluation_record
+        WHERE runtime_scope_id = @scope
+          AND observed_rule_hash = @hash
+          AND observed_rule_snapshot IS NOT NULL
+        GROUP BY observed_rule_snapshot
+        ORDER BY observed_rule_snapshot`)
+        .all({ scope: runtimeScopeId, hash: observedRuleHash });
+    if (groups.length === 0) {
+        return { kind: "NOT_FOUND", runtimeScopeId, observedRuleHash };
+    }
+    if (groups.length > 1) {
+        return { kind: "COLLISION", runtimeScopeId, observedRuleHash, distinctSnapshotCount: groups.length };
+    }
+    return {
+        kind: "FOUND",
+        observedRuleHash,
+        observedRuleSnapshot: groups[0].snapshot,
+        observationCount: groups[0].n,
+    };
+}

package/dist/lib/rules/live-input-authority.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUserHookConfigLayer = readUserHookConfigLayer;
+exports.resolveLiveInputAuthority = resolveLiveInputAuthority;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const input_authority_resolver_1 = require("./input-authority-resolver");
+// The production input-authority loader for the R1 pilot (P0.58). It feeds the pure resolver the single
+// user config layer from ~/.claude/settings.json, the only layer the installer writes for the
+// single-operator pilot (P0.3). An absent settings file is a readable empty layer (the resolver concludes
+// MLA_HOOK_ABSENT, the honest "not wired" state); a file that exists but will not parse is marked
+// unreadable so the resolver fails CLOSED (CONFIG_LAYER_UNREADABLE) rather than concluding MLA is sole
+// authority. This is the single source of truth shared by `mla doctor` and the live PreToolUse hook so
+// both judge admissibility off identical inputs.
+function readUserHookConfigLayer(homeDir = os.homedir()) {
+    const settingsPath = path.join(homeDir, ".claude", "settings.json");
+    if (!fs.existsSync(settingsPath)) {
+        return { name: "user", settings: {} };
+    }
+    try {
+        return { name: "user", settings: JSON.parse(fs.readFileSync(settingsPath, "utf8")) };
+    }
+    catch (e) {
+        return { name: "user", unreadable: true, error: e.message };
+    }
+}
+function resolveLiveInputAuthority(opts = {}) {
+    return (0, input_authority_resolver_1.resolveInputAuthority)([readUserHookConfigLayer(opts.homeDir)], {
+        mlaHooksDir: opts.mlaHooksDir ?? config_1.HOOKS_DIR,
+    });
+}

package/dist/lib/rules/local-matcher.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateLocalMatcher = evaluateLocalMatcher;
+exports.parseLocalMatcherRule = parseLocalMatcherRule;
+const command_match_1 = require("./command-match");
+const content_match_1 = require("./content-match");
+const evaluator_1 = require("./evaluator");
+/**
+ * Evaluate a tool call against an observe-only local matcher rule. Returns null
+ * when the rule does not select this call (the tool is not in its list), which is
+ * distinct from an applied rule that returns UNKNOWN. When it applies, the verdict
+ * is the reduction over every named field:
+ *   - content: any field CONTAINS_FORBIDDEN wins (VIOLATION); else any provably
+ *     clean string field is COMPLIANT; else INDETERMINATE (UNKNOWN). A present,
+ *     clean field is not dragged down by an absent sibling field.
+ *   - command: any field MATCHES_FORBIDDEN wins (VIOLATION); else NO_MATCH
+ *     (UNKNOWN, opaque, never COMPLIANT); else INDETERMINATE (UNKNOWN).
+ */
+function evaluateLocalMatcher(call, rule) {
+    if (!rule.tools.includes(call.toolName)) {
+        return null;
+    }
+    const values = rule.fields.map((field) => call.toolInput[field]);
+    if (rule.kind === "content") {
+        const classes = values.map((v) => (0, content_match_1.classifyContent)(v, rule.forbiddenSubstrings));
+        return (0, evaluator_1.verdictForForbiddenContent)(reduceContent(classes));
+    }
+    const classes = values.map((v) => (0, command_match_1.classifyCommand)(v, rule.forbiddenSequences));
+    return (0, evaluator_1.verdictForForbiddenCommand)(reduceCommand(classes));
+}
+/** A forbidden hit anywhere wins; else a provable clean read; else indeterminate. */
+function reduceContent(classes) {
+    if (classes.includes("CONTAINS_FORBIDDEN")) {
+        return "CONTAINS_FORBIDDEN";
+    }
+    if (classes.includes("NO_FORBIDDEN")) {
+        return "NO_FORBIDDEN";
+    }
+    return "INDETERMINATE";
+}
+/** A forbidden hit anywhere wins; else an opaque non-match; else indeterminate. */
+function reduceCommand(classes) {
+    if (classes.includes("MATCHES_FORBIDDEN")) {
+        return "MATCHES_FORBIDDEN";
+    }
+    if (classes.includes("NO_MATCH")) {
+        return "NO_MATCH";
+    }
+    return "INDETERMINATE";
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyStringArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === "string" && v.length > 0);
+}
+function invalid(diagnostic) {
+    return { status: "INVALID", diagnostic };
+}
+/**
+ * Validate an untrusted local matcher rule descriptor (e.g. read from disk). A
+ * misconfiguration that could never fire usefully (empty tools, empty fields, no
+ * usable forbidden needle) is rejected at parse time rather than silently always
+ * returning UNKNOWN at evaluation time.
+ */
+function parseLocalMatcherRule(raw) {
+    if (!isPlainObject(raw)) {
+        return invalid("rule must be an object");
+    }
+    if (!isNonEmptyStringArray(raw.tools)) {
+        return invalid("tools must be a non-empty array of non-empty strings");
+    }
+    if (!isNonEmptyStringArray(raw.fields)) {
+        return invalid("fields must be a non-empty array of non-empty strings");
+    }
+    if (raw.kind === "content") {
+        if (!isNonEmptyStringArray(raw.forbiddenSubstrings)) {
+            return invalid("content rule needs at least one non-empty forbidden substring");
+        }
+        return {
+            status: "OK",
+            rule: {
+                kind: "content",
+                tools: [...raw.tools],
+                fields: [...raw.fields],
+                forbiddenSubstrings: [...raw.forbiddenSubstrings],
+            },
+        };
+    }
+    if (raw.kind === "command") {
+        const sequences = raw.forbiddenSequences;
+        if (!Array.isArray(sequences) ||
+            sequences.length === 0 ||
+            !sequences.every((seq) => isNonEmptyStringArray(seq))) {
+            return invalid("command rule needs at least one non-empty forbidden token sequence");
+        }
+        return {
+            status: "OK",
+            rule: {
+                kind: "command",
+                tools: [...raw.tools],
+                fields: [...raw.fields],
+                forbiddenSequences: sequences.map((seq) => [...seq]),
+            },
+        };
+    }
+    return invalid(`unknown matcher kind: ${String(raw.kind)}`);
+}

package/dist/lib/rules/local-observe.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_LOCAL_OBSERVE_RULES = void 0;
+exports.observeLocalMatchers = observeLocalMatchers;
+const local_matcher_1 = require("./local-matcher");
+const observe_adapter_1 = require("./observe-adapter");
+/**
+ * Evaluate every supplied local matcher rule against a raw PreToolUse payload
+ * (an object or the JSON string delivered on stdin). Rules that do not select the
+ * call (wrong tool) are omitted; only rules that actually applied contribute an
+ * observation. A payload that is not a usable PreToolUse call yields [].
+ */
+function observeLocalMatchers(rawInput, rules) {
+    const parsed = (0, observe_adapter_1.parsePreToolUseInput)(rawInput);
+    if (parsed === null) {
+        return [];
+    }
+    const call = { toolName: parsed.tool_name, toolInput: parsed.tool_input };
+    const observations = [];
+    for (const { id, rule } of rules) {
+        const verdict = (0, local_matcher_1.evaluateLocalMatcher)(call, rule);
+        if (verdict !== null) {
+            observations.push({ ruleId: id, result: verdict.result, reasonCode: verdict.reasonCode });
+        }
+    }
+    return observations;
+}
+// Candidate observe-only rules derived directly from An's own documented rules
+// (global CLAUDE.md + this repo's feedback memory). They are DATA, not armed: nothing
+// in this slice wires them onto the hot path or denies on them. They exist so the
+// future recording/arming slice (An-owned, once the identity contract lands) has a
+// concrete, well-formed starting set rather than an empty one. Each is a sound,
+// observe-only matcher: a CONTENT rule produces a real COMPLIANT/VIOLATION (the field
+// is fully observable); a COMMAND rule only ever produces VIOLATION-or-UNKNOWN.
+exports.BUILTIN_LOCAL_OBSERVE_RULES = [
+    {
+        // An's #1 AI-smell rule: never write an em dash or a double dash into a file.
+        id: "no-em-dash-or-double-dash-in-writes",
+        rule: {
+            kind: "content",
+            tools: ["Write", "Edit"],
+            fields: ["content", "new_string"],
+            forbiddenSubstrings: ["—", "--"],
+        },
+    },
+    {
+        // "push only when explicitly asked" (merge != push).
+        id: "no-unrequested-git-push",
+        rule: {
+            kind: "command",
+            tools: ["Bash"],
+            fields: ["command"],
+            forbiddenSequences: [["git", "push"]],
+        },
+    },
+    {
+        // "NEVER create feature branches; work directly on main."
+        id: "no-feature-branch",
+        rule: {
+            kind: "command",
+            tools: ["Bash"],
+            fields: ["command"],
+            forbiddenSequences: [
+                ["git", "checkout", "-b"],
+                ["git", "switch", "-c"],
+            ],
+        },
+    },
+    {
+        // "never hand-roll prisma migrate deploy; use make test-db."
+        id: "no-hand-rolled-prisma-migrate-deploy",
+        rule: {
+            kind: "command",
+            tools: ["Bash"],
+            fields: ["command"],
+            forbiddenSequences: [["prisma", "migrate", "deploy"]],
+        },
+    },
+];