@dalzoubi/dev-agents-sync 2.0.28 → 2.2.0

package/tests/hooks-wave2-registration.test.mjs

@@ -0,0 +1,523 @@
+/**
+ * tests/hooks-wave2-registration.test.mjs
+ *
+ * Slice S5 — CLI wiring for the 260805 hooks wave.
+ * Spec: docs/specs/260805-hooks-wave-2/
+ *
+ * The wave adds five hooks — three BLOCKING (PreToolUse, exit 2) and two
+ * warning — to a pipeline that previously carried only non-blocking reminders.
+ * Nothing in the CLI changed to carry them: `collectHookPaths` /
+ * `hookScriptsForInstalled` are predicate-driven, so the whole slice is five
+ * rows in `DEFAULT_HOOK_SCRIPTS`. That is precisely why it needs tests: a wrong
+ * event or matcher installs a hook that never fires (or fires on every tool
+ * call), and nothing else in the suite would notice.
+ *
+ * Behavior anchors:
+ *
+ *  W1. Each of the five hooks is registered on the event and matcher the plan's
+ *      registration table specifies.
+ *  W2. `init` and `update` install and wire every registered hook — asserted
+ *      against the registration table, not a pinned count, so a hook added
+ *      later cannot slip through uncovered.
+ *  W3. The settings merge stays idempotent with the larger table: a second
+ *      `update` leaves settings.json byte-identical (twice == once).
+ *  W4. A pre-wave lockfile (recording only the three 260616 hooks) upgrades
+ *      additively — no error, and the new hooks land.
+ *  W5. `check` reports drift (exit 1) when a wave-2 hook script is modified.
+ *
+ * The wave-2 hooks' own runtime behavior (deny/allow/bypass/fail-open) is
+ * proven by the content repo's `tests/hooks-*.test.mjs`; the fixture bodies
+ * here are inert stand-ins, since this file is about wiring, not detection.
+ *
+ * Fixture pattern mirrors tests/hooks-cli-install.test.mjs (release-v1.0.0
+ * FileMap + injected hook entries carrying the shell-comment marker).
+ *
+ * Test runner: `node --test packages/dev-agents-sync/tests/hooks-wave2-registration.test.mjs`
+ * i18n/accessibility: N/A — CLI-only, no UI surface and no translated strings.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  rmSync,
+  readdirSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runInit } from '../src/commands/init.mjs';
+import { runUpdate } from '../src/commands/update.mjs';
+import { runCheck } from '../src/commands/check.mjs';
+import { DEFAULT_HOOK_SCRIPTS, HOOK_TAG } from '../src/settings.mjs';
+
+// ---------------------------------------------------------------------------
+// Paths / fixtures
+// ---------------------------------------------------------------------------
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURE_DIR = path.join(__dirname, 'fixtures', 'release-v1.0.0');
+const AVAILABLE_TAGS = ['v1.0.0', 'v1.1.0', 'v1.2.0', 'v2.0.0'];
+const LOCKFILE_NAME = '.dev-agents-sync.json';
+
+/**
+ * The registration table this slice adds, restated from
+ * docs/specs/260805-hooks-wave-2/plan.md.
+ *
+ * Deliberately a literal: this is the CONTRACT under test (which event fires
+ * which hook, and on which tools), not an inventory of what happens to exist.
+ * Deriving it from DEFAULT_HOOK_SCRIPTS would assert the table equals itself.
+ * It stays valid as later waves append rows — nothing here claims the table
+ * holds ONLY these five.
+ */
+const WAVE2_REGISTRATIONS = [
+  { command: '.claude/hooks/force-push-guard.sh', event: 'PreToolUse', matcher: 'Bash' },
+  { command: '.claude/hooks/spec-approval-gate.sh', event: 'PreToolUse', matcher: 'Edit|Write' },
+  { command: '.claude/hooks/handoff-state-guard.sh', event: 'PreToolUse', matcher: 'Write' },
+  { command: '.claude/hooks/spec-drift-warn.sh', event: 'PostToolUse', matcher: 'Edit|Write' },
+  { command: '.claude/hooks/pre-pr-preflight.sh', event: 'PreToolUse', matcher: 'Bash' },
+];
+
+function collectFiles(baseDir, currentDir, map, prefix) {
+  for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+    const full = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(baseDir, full, map, prefix);
+    } else {
+      const rel = path.relative(baseDir, full).replace(/\\/g, '/');
+      map[`${prefix}/${rel}`] = readFileSync(full, 'utf8');
+    }
+  }
+}
+
+/**
+ * A fetched FileMap carrying one hook script per registration — the shape the
+ * build emits (`claude/hooks/<name>.sh`, shell-comment marker, since the CLI
+ * keys managed hooks off that prefix).
+ */
+function buildFixtureFileMap() {
+  const map = {};
+  const targetDir = path.join(FIXTURE_DIR, 'claude');
+  if (existsSync(targetDir)) collectFiles(targetDir, targetDir, map, 'claude');
+  for (const { event, command } of DEFAULT_HOOK_SCRIPTS) {
+    map[command.replace(/^\.claude\//, 'claude/')] =
+      `#!/bin/sh\n# managed-by: dev-agents-sync v2.0.16\n# ${event} hook fixture: ${path.basename(command)}.\nexit 0\n`;
+  }
+  return map;
+}
+
+function makeFixtureFetcher() {
+  return async (_repo, _tag, _token) => buildFixtureFileMap();
+}
+
+function makeTmpDir() {
+  return mkdtempSync(path.join(tmpdir(), 'das-hooks-wave2-'));
+}
+
+/**
+ * Seeds a consumer that last synced BEFORE this wave: the lockfile records only
+ * the three 260616 hooks, and only those three exist on disk.
+ */
+function setupPreWaveRepo(consumerDir) {
+  const raw =
+    JSON.stringify(
+      {
+        $schema:
+          'https://raw.githubusercontent.com/dalzoubi/dev-agents/v1/schema/lockfile.schema.json',
+        source: 'github:dalzoubi/dev-agents',
+        range: '^1',
+        resolvedVersion: '1.0.0',
+        targets: ['claude'],
+        lastUpdated: '2026-06-01T00:00:00Z',
+        hooks: [
+          '.claude/hooks/managed-file-guard.sh',
+          '.claude/hooks/steering-injector.sh',
+          '.claude/hooks/uncommitted-check.sh',
+        ],
+      },
+      null,
+      2,
+    ) + '\n';
+  writeFileSync(path.join(consumerDir, LOCKFILE_NAME), raw, 'utf8');
+
+  const agentsDir = path.join(consumerDir, '.claude', 'agents');
+  mkdirSync(agentsDir, { recursive: true });
+  writeFileSync(
+    path.join(agentsDir, 'define.md'),
+    readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'define.md'), 'utf8'),
+    'utf8',
+  );
+}
+
+/** Every CLI-managed registration in settings.json, flattened to {event, matcher, command}. */
+function managedRegistrations(consumerDir) {
+  const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+  if (!existsSync(settingsPath)) return [];
+  const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  const out = [];
+  for (const [event, entries] of Object.entries(settings.hooks ?? {})) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (entry?.[HOOK_TAG] !== true) continue;
+      for (const h of entry.hooks ?? []) {
+        if (typeof h.command === 'string') {
+          out.push({ event, matcher: entry.matcher, command: h.command });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// W1 — the registration table matches the plan
+// ---------------------------------------------------------------------------
+
+describe('W1 — the five wave-2 hooks are registered on the specified event and matcher', () => {
+  for (const { command, event, matcher } of WAVE2_REGISTRATIONS) {
+    it(`W1: ${path.basename(command)} is registered on ${event} with matcher "${matcher}"`, () => {
+      const entries = DEFAULT_HOOK_SCRIPTS.filter((h) => h.command === command);
+      assert.equal(
+        entries.length,
+        1,
+        `${command} must have exactly one DEFAULT_HOOK_SCRIPTS entry; got ${entries.length}`,
+      );
+      assert.deepEqual(
+        { event: entries[0].event, matcher: entries[0].matcher },
+        { event, matcher },
+        `${command} must be wired per docs/specs/260805-hooks-wave-2/plan.md. A wrong event ` +
+          `means the hook never sees the call it guards; a wrong matcher means it is spawned ` +
+          `on unrelated tool calls (or skipped on the ones that matter).`,
+      );
+    });
+  }
+
+  it('W1: every blocking hook is registered on PreToolUse (the only event that can deny)', () => {
+    // Exit 2 denies the tool call on PreToolUse and nowhere else — a blocker
+    // registered on any other event is inert, and silently so.
+    const blockers = [
+      '.claude/hooks/force-push-guard.sh',
+      '.claude/hooks/spec-approval-gate.sh',
+      '.claude/hooks/handoff-state-guard.sh',
+    ];
+    for (const command of blockers) {
+      const entry = DEFAULT_HOOK_SCRIPTS.find((h) => h.command === command);
+      assert.ok(entry, `${command} must be registered`);
+      assert.equal(
+        entry.event,
+        'PreToolUse',
+        `${command} blocks by exiting 2, which only denies on PreToolUse; on ${entry.event} it ` +
+          `would be a hook that reports failure and lets the call through`,
+      );
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// W2 — init/update install and wire every registered hook
+// ---------------------------------------------------------------------------
+
+describe('W2 — init and update install and wire every registered hook', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('W2a: init installs a script on disk for every registration', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const missing = DEFAULT_HOOK_SCRIPTS.map((h) => h.command).filter(
+      (c) => !existsSync(path.join(consumerDir, c)),
+    );
+    assert.deepEqual(missing, [], `init must install every registered hook script; missing: ${missing}`);
+  });
+
+  it('W2b: init wires every registration into settings.json with its event and matcher', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const wired = managedRegistrations(consumerDir);
+    for (const { event, matcher, command } of DEFAULT_HOOK_SCRIPTS) {
+      assert.ok(
+        wired.some((w) => w.command === command && w.event === event && w.matcher === matcher),
+        `settings.json must wire ${command} on ${event} with matcher "${matcher}"; ` +
+          `got: ${JSON.stringify(wired, null, 2)}`,
+      );
+    }
+  });
+
+  it('W2c: update wires every registration into settings.json', async () => {
+    setupPreWaveRepo(consumerDir);
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const wired = managedRegistrations(consumerDir);
+    for (const { event, matcher, command } of DEFAULT_HOOK_SCRIPTS) {
+      assert.ok(
+        wired.some((w) => w.command === command && w.event === event && w.matcher === matcher),
+        `update must wire ${command} on ${event} with matcher "${matcher}"; ` +
+          `got: ${JSON.stringify(wired, null, 2)}`,
+      );
+    }
+  });
+
+  it('W2d: the two Bash PreToolUse hooks are both wired (a shared event+matcher is not deduped)', async () => {
+    // force-push-guard and pre-pr-preflight share PreToolUse/Bash. Merge
+    // identity is the COMMAND, so both must survive — collapsing on
+    // event+matcher would silently drop one.
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const commands = managedRegistrations(consumerDir)
+      .filter((w) => w.event === 'PreToolUse' && w.matcher === 'Bash')
+      .map((w) => w.command)
+      .sort();
+    assert.deepEqual(
+      commands,
+      ['.claude/hooks/force-push-guard.sh', '.claude/hooks/pre-pr-preflight.sh'],
+      'both PreToolUse/Bash hooks must be wired independently',
+    );
+  });
+
+  it('W2e: installed hook scripts are recorded in the lockfile', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const raw = readFileSync(path.join(consumerDir, LOCKFILE_NAME), 'utf8');
+    for (const { command } of WAVE2_REGISTRATIONS) {
+      assert.ok(raw.includes(path.basename(command)), `lockfile must track ${command}`);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// W3 — idempotence with the larger registration table
+// ---------------------------------------------------------------------------
+
+describe('W3 — a second update is a no-op (twice == once)', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('W3a: settings.json is byte-identical after a second update', async () => {
+    setupPreWaveRepo(consumerDir);
+    const opts = { fetcher: makeFixtureFetcher(), availableTags: AVAILABLE_TAGS };
+
+    await runUpdate(consumerDir, opts);
+    const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+    const first = readFileSync(settingsPath, 'utf8');
+
+    await runUpdate(consumerDir, opts);
+    const second = readFileSync(settingsPath, 'utf8');
+
+    assert.equal(
+      second,
+      first,
+      'a second update must not rewrite settings.json — the merge is idempotent (§9)',
+    );
+  });
+
+  it('W3b: no hook command is registered twice after two updates', async () => {
+    setupPreWaveRepo(consumerDir);
+    const opts = { fetcher: makeFixtureFetcher(), availableTags: AVAILABLE_TAGS };
+
+    await runUpdate(consumerDir, opts);
+    await runUpdate(consumerDir, opts);
+
+    const commands = managedRegistrations(consumerDir).map((w) => w.command);
+    const duplicated = commands.filter((c, i) => commands.indexOf(c) !== i);
+    assert.deepEqual(duplicated, [], `duplicate registrations after two updates: ${duplicated}`);
+  });
+
+  it('W3c: hook scripts on disk are byte-identical after a second update', async () => {
+    setupPreWaveRepo(consumerDir);
+    const opts = { fetcher: makeFixtureFetcher(), availableTags: AVAILABLE_TAGS };
+
+    await runUpdate(consumerDir, opts);
+    const first = DEFAULT_HOOK_SCRIPTS.map((h) =>
+      readFileSync(path.join(consumerDir, h.command), 'utf8'),
+    );
+
+    await runUpdate(consumerDir, opts);
+    const second = DEFAULT_HOOK_SCRIPTS.map((h) =>
+      readFileSync(path.join(consumerDir, h.command), 'utf8'),
+    );
+
+    assert.deepEqual(second, first, 'hook scripts must be byte-identical after a second update');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// W4 — pre-wave lockfile upgrades additively (§8)
+// ---------------------------------------------------------------------------
+
+describe('W4 — a pre-wave lockfile upgrades additively', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('W4a: update against a lockfile listing only the pre-wave hooks does not throw', async () => {
+    setupPreWaveRepo(consumerDir);
+    await assert.doesNotReject(
+      runUpdate(consumerDir, { fetcher: makeFixtureFetcher(), availableTags: AVAILABLE_TAGS }),
+      'a lockfile written before this wave must upgrade without error (§8)',
+    );
+  });
+
+  it('W4b: the upgraded lockfile keeps the pre-wave hooks and gains the new ones', async () => {
+    setupPreWaveRepo(consumerDir);
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const raw = readFileSync(path.join(consumerDir, LOCKFILE_NAME), 'utf8');
+    // Additive: nothing the consumer already had is dropped...
+    for (const name of ['steering-injector.sh', 'managed-file-guard.sh', 'uncommitted-check.sh']) {
+      assert.ok(raw.includes(name), `upgrade must not drop the pre-wave hook ${name}`);
+    }
+    // ...and the wave's hooks are added.
+    for (const { command } of WAVE2_REGISTRATIONS) {
+      assert.ok(raw.includes(path.basename(command)), `upgrade must record ${command}`);
+    }
+  });
+
+  it('W4c: a consumer-authored settings.json survives the upgrade untouched', async () => {
+    setupPreWaveRepo(consumerDir);
+    const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+    mkdirSync(path.dirname(settingsPath), { recursive: true });
+    writeFileSync(
+      settingsPath,
+      JSON.stringify(
+        {
+          env: { MY_KEY: 'value' },
+          hooks: { PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'mine.sh' }] }] },
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    assert.deepEqual(settings.env, { MY_KEY: 'value' }, 'consumer env must survive');
+    assert.ok(
+      settings.hooks.PreToolUse.some((e) =>
+        (e.hooks ?? []).some((h) => h.command === 'mine.sh'),
+      ),
+      'a consumer-authored PreToolUse/Bash hook must survive alongside the new managed ones',
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// W5 — check reports drift on a modified wave-2 hook script
+// ---------------------------------------------------------------------------
+
+describe('W5 — check reports drift on a modified hook script', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  async function runCheckExitCode(dir) {
+    try {
+      await runCheck(dir, { fetcher: makeFixtureFetcher(), availableTags: ['v1.2.0'] });
+      return 0;
+    } catch (err) {
+      return err.exitCode ?? 1;
+    }
+  }
+
+  it('W5a: check exits 0 on a clean tree with the full hook set installed', async () => {
+    setupPreWaveRepo(consumerDir);
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: ['v1.0.0', 'v1.2.0'],
+    });
+
+    assert.equal(await runCheckExitCode(consumerDir), 0, 'a synced tree must be clean');
+  });
+
+  it('W5b: editing a blocking hook script makes check exit 1', async () => {
+    // The drift signal matters more for a blocker than for a reminder: a
+    // locally weakened force-push-guard still looks installed and wired.
+    setupPreWaveRepo(consumerDir);
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: ['v1.0.0', 'v1.2.0'],
+    });
+
+    const hookPath = path.join(consumerDir, '.claude', 'hooks', 'force-push-guard.sh');
+    writeFileSync(hookPath, readFileSync(hookPath, 'utf8') + '\n# locally weakened\n', 'utf8');
+
+    assert.equal(
+      await runCheckExitCode(consumerDir),
+      1,
+      'check must report drift when a managed hook script is locally modified',
+    );
+  });
+
+  it('W5c: deleting a wave-2 hook script makes check exit 1', async () => {
+    setupPreWaveRepo(consumerDir);
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: ['v1.0.0', 'v1.2.0'],
+    });
+
+    rmSync(path.join(consumerDir, '.claude', 'hooks', 'handoff-state-guard.sh'));
+
+    assert.equal(
+      await runCheckExitCode(consumerDir),
+      1,
+      'check must report drift when a managed hook script is deleted',
+    );
+  });
+});

package/tests/rules-injector-registration.test.mjs

@@ -26,8 +26,8 @@
  * Behavior anchors:
  *
  *  R1. DEFAULT_HOOK_SCRIPTS (packages/dev-agents-sync/src/settings.mjs) no
- *      longer has an entry targeting `.claude/hooks/rules-injector.sh`; it
- *      registers exactly the three surviving hooks.
+ *      longer has an entry targeting `.claude/hooks/rules-injector.sh`, and no
+ *      retired command is ever re-registered; the three surviving hooks remain.
  *  R2. `runInit` on a fresh consumer never wires a SessionStart registration
  *      for rules-injector.sh into `.claude/settings.json` — the three
  *      surviving managed hooks are still wired additively.
@@ -65,7 +65,7 @@ import { fileURLToPath } from 'node:url';
 import { runInit } from '../src/commands/init.mjs';
 import { runUpdate } from '../src/commands/update.mjs';
 import { writeLockfile } from '../src/lockfile.mjs';
-import { DEFAULT_HOOK_SCRIPTS, HOOK_TAG } from '../src/settings.mjs';
+import { DEFAULT_HOOK_SCRIPTS, RETIRED_HOOK_SCRIPTS, HOOK_TAG } from '../src/settings.mjs';
 
 // ---------------------------------------------------------------------------
 // Paths / fixture helpers (mirrors tests/hooks-cli-install.test.mjs)
@@ -220,18 +220,21 @@ describe('S1 R1 — DEFAULT_HOOK_SCRIPTS no longer includes rules-injector.sh (r
     );
   });
 
-  it('R1b: DEFAULT_HOOK_SCRIPTS registers exactly the three surviving hooks', () => {
-    const commands = DEFAULT_HOOK_SCRIPTS.map((h) => h.command).sort();
-    const expected = [
-      '.claude/hooks/managed-file-guard.sh',
-      '.claude/hooks/steering-injector.sh',
-      '.claude/hooks/uncommitted-check.sh',
-    ].sort();
+  it('R1b: DEFAULT_HOOK_SCRIPTS and RETIRED_HOOK_SCRIPTS are disjoint (no retired command is re-registered)', () => {
+    // Generalizes what a pinned three-command roster used to assert here. The
+    // invariant R1 actually protects is that retirement holds — a command on
+    // the append-only retired list must never reappear in the shipped table, or
+    // merge-then-prune would add it and immediately remove it on every run.
+    // Stating it against the two tables keeps that guard exact while letting a
+    // wave register new hooks (260805 registered five) without a hand-edit.
+    const registered = DEFAULT_HOOK_SCRIPTS.map((h) => h.command);
+    const retired = new Set(RETIRED_HOOK_SCRIPTS.map((h) => h.command));
+    const reRegistered = registered.filter((c) => retired.has(c)).sort();
     assert.deepEqual(
-      commands,
-      expected,
-      `DEFAULT_HOOK_SCRIPTS must register exactly the three surviving hooks, no more, no fewer; ` +
-        `got: ${commands.join(', ')}`,
+      reRegistered,
+      [],
+      `DEFAULT_HOOK_SCRIPTS must not register any command on RETIRED_HOOK_SCRIPTS; ` +
+        `got: ${reRegistered.join(', ')}`,
     );
   });