@polderlabs/bizar 7.0.4 → 8.1.0

package/bizar-dash/tests/components/Toast.test.tsx

@@ -1,108 +1,61 @@
-import { render, screen, act, fireEvent } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import { describe, it, expect, vi } from 'vitest';
-import { ToastContainer, ToastProvider, useToast } from '../../src/web/components/Toast';
-
-function ToastHarness() {
-  const toast = useToast();
-  return (
-    <div>
-      <button onClick={() => toast.show('Info message')}>Show Info</button>
-      <button onClick={() => toast.success('Success!')}>Show Success</button>
-      <button onClick={() => toast.error('Error!')}>Show Error</button>
-    </div>
-  );
-}
-
-describe('ToastContainer', () => {
-  it('renders toast with message', () => {
-    render(
-      <ToastContainer
-        toasts={[{ id: 1, kind: 'info', message: 'Test toast' }]}
-        onDismiss={() => {}}
-      />,
-    );
-    expect(screen.getByText('Test toast')).toBeInTheDocument();
+/**
+ * tests/components/Toast.test.tsx
+ *
+ * v8 migration — Toast test rewritten against the v8 Toaster / toast API.
+ *
+ * v7 used a `<ToastProvider>` context with imperative `toast()` calls.
+ * v8 uses Sonner directly: render `<Toaster />` once at the app root and
+ * call `toast.success(...)` / `toast.error(...)` from anywhere.
+ *
+ * Sonner renders toasts asynchronously into a portal — assertions use
+ * `findBy*` / `waitFor` rather than synchronous `getBy*`.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { Toaster, toast } from '../../src/web/v8/ui/index.js';
+
+describe('Toaster (v8)', () => {
+  afterEach(() => {
+    // Sonner keeps toasts in state across tests unless we explicitly dismiss.
+    toast.dismiss();
   });
 
-  it('has role="alert" and aria-live="assertive"', () => {
-    render(
-      <ToastContainer
-        toasts={[{ id: 1, kind: 'info', message: 'Accessible toast' }]}
-        onDismiss={() => {}}
-      />,
-    );
-    const toast = screen.getByRole('alert');
-    expect(toast).toBeInTheDocument();
-    expect(toast).toHaveAttribute('aria-live', 'assertive');
+  it('renders the Sonner Toaster container', () => {
+    render(<Toaster />);
+    // Sonner exposes an `aria-label="Notifications"` region for SR users.
+    const region = screen.getByLabelText(/notifications/i);
+    expect(region).toBeInTheDocument();
   });
-});
 
-describe('ToastProvider + useToast', () => {
-  afterEach(() => {
-    vi.useRealTimers();
+  it('exposes the imperative toast surface', () => {
+    expect(typeof toast.success).toBe('function');
+    expect(typeof toast.error).toBe('function');
+    expect(typeof toast.info).toBe('function');
+    expect(typeof toast.warning).toBe('function');
+    expect(typeof toast.message).toBe('function');
+    expect(typeof toast.dismiss).toBe('function');
   });
 
-  it('displays a toast when show is called', async () => {
-    const user = userEvent.setup();
-    render(
-      <ToastProvider>
-        <ToastHarness />
-      </ToastProvider>,
-    );
-
-    await user.click(screen.getByText('Show Info'));
-    expect(screen.getByText('Info message')).toBeInTheDocument();
+  it('toast.success emits a toast with the message text', async () => {
+    render(<Toaster />);
+    toast.success('Saved!');
+    expect(await screen.findByText('Saved!')).toBeInTheDocument();
   });
 
-  it('displays multiple toasts stacked', async () => {
-    const user = userEvent.setup();
-    render(
-      <ToastProvider>
-        <ToastHarness />
-      </ToastProvider>,
-    );
-
-    await user.click(screen.getByText('Show Success'));
-    await user.click(screen.getByText('Show Error'));
-
-    expect(screen.getByText('Success!')).toBeInTheDocument();
-    expect(screen.getByText('Error!')).toBeInTheDocument();
+  it('toast.error emits a toast with the error message text', async () => {
+    render(<Toaster />);
+    toast.error('Boom');
+    expect(await screen.findByText('Boom')).toBeInTheDocument();
   });
 
-  it('auto-dismisses after the default timeout', () => {
-    // Use fireEvent (synchronous) instead of userEvent to avoid
-    // timer conflicts with vi.useFakeTimers
-    vi.useFakeTimers();
-
-    render(
-      <ToastProvider>
-        <ToastHarness />
-      </ToastProvider>,
-    );
-
-    fireEvent.click(screen.getByText('Show Info'));
-    expect(screen.getByText('Info message')).toBeInTheDocument();
-
-    act(() => {
-      vi.advanceTimersByTime(4000);
+  it('toast.dismiss removes a previously shown toast', async () => {
+    render(<Toaster />);
+    toast.warning('Heads up');
+    const node = await screen.findByText('Heads up');
+    expect(node).toBeInTheDocument();
+    toast.dismiss();
+    await waitFor(() => {
+      expect(screen.queryByText('Heads up')).not.toBeInTheDocument();
     });
-
-    expect(screen.queryByText('Info message')).not.toBeInTheDocument();
-  });
-
-  it('dismisses a toast when dismiss button is clicked', async () => {
-    const user = userEvent.setup();
-    render(
-      <ToastProvider>
-        <ToastHarness />
-      </ToastProvider>,
-    );
-
-    await user.click(screen.getByText('Show Info'));
-    expect(screen.getByText('Info message')).toBeInTheDocument();
-
-    await user.click(screen.getByLabelText('Dismiss'));
-    expect(screen.queryByText('Info message')).not.toBeInTheDocument();
   });
 });

package/bizar-dash/tests/goals-decompose.test.mjs

@@ -0,0 +1,177 @@
+/**
+ * goals-decompose.test.mjs — tests for goal → task auto-decomposition
+ * (Sprint S18). Covers:
+ *
+ *   - POST /api/goals/:id/decompose creates one queued task per KR.
+ *   - PATCH /api/tasks/:id/status (done) flows back to mark KR done
+ *     and recomputes goal.progress%.
+ *   - Re-decomposing a goal leaves existing taskIds intact.
+ *
+ * Run with: node --test bizar-dash/tests/goals-decompose.test.mjs
+ */
+import { describe, it, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let SANDBOX_HOME;
+let ORIGINAL_HOME;
+let app;
+let progressPath;
+
+before(async () => {
+  SANDBOX_HOME = mkdtempSync(join(tmpdir(), `bizar-goals-test-${Date.now()}-`));
+  ORIGINAL_HOME = process.env.HOME;
+  process.env.HOME = SANDBOX_HOME;
+  mkdirSync(join(SANDBOX_HOME, '.bizar'), { recursive: true });
+  progressPath = join(SANDBOX_HOME, '.bizar', 'PROGRESS.md');
+
+  // Seed PROGRESS.md with one goal + three key results.
+  writeFileSync(progressPath, [
+    '# PROGRESS',
+    '',
+    '## Ship the v8 dashboard',
+    '',
+    'status: at-risk',
+    'progress: 0',
+    'due: 2026-09-30',
+    'owner: sam',
+    '',
+    '- [ ] Wire backend SSE  ← kr-1',
+    '- [ ] Wire command palette  ← kr-2',
+    '- [ ] Wire settings  ← kr-3',
+    '',
+  ].join('\n'), 'utf8');
+
+  const { createGoalsRouter } = await import('../src/server/routes/goals.mjs');
+  const { createTasksRouter } = await import('../src/server/routes/tasks.mjs');
+  // tasks-store writes to ~/.config/cline/projects/<id>/tasks.json
+  mkdirSync(join(SANDBOX_HOME, '.config', 'cline', 'projects', 'default'), { recursive: true });
+
+  app = express();
+  app.use(express.json());
+  app.use('/api', createGoalsRouter({ broadcast: () => {} }));
+  app.use('/api', createTasksRouter({ state: {}, broadcast: () => {}, projectRoot: SANDBOX_HOME }));
+});
+
+after(async () => {
+  process.env.HOME = ORIGINAL_HOME;
+  rmSync(SANDBOX_HOME, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  // Reset PROGRESS.md between tests so seed state is reproducible.
+  writeFileSync(progressPath, [
+    '# PROGRESS',
+    '',
+    '## Ship the v8 dashboard',
+    '',
+    'status: at-risk',
+    'progress: 0',
+    'due: 2026-09-30',
+    'owner: sam',
+    '',
+    '- [ ] Wire backend SSE  ← kr-1',
+    '- [ ] Wire command palette  ← kr-2',
+    '- [ ] Wire settings  ← kr-3',
+    '',
+  ].join('\n'), 'utf8');
+});
+
+async function http(method, path, body) {
+  return new Promise((resolve, reject) => {
+    const server = app.listen(0, '127.0.0.1', async () => {
+      try {
+        const port = server.address().port;
+        const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+          method,
+          headers: { 'content-type': 'application/json' },
+          body: body ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        let json;
+        try { json = text ? JSON.parse(text) : null; } catch { json = text; }
+        server.close();
+        resolve({ status: res.status, body: json });
+      } catch (err) { server.close(); reject(err); }
+    });
+  });
+}
+
+describe('Goals → Tasks auto-decomposition', () => {
+  it('decomposes a goal into one task per key result', async () => {
+    const goalsList = await http('GET', '/api/goals');
+    assert.equal(goalsList.status, 200);
+    const goal = goalsList.body.goals[0];
+    assert.ok(Array.isArray(goal.keyResults) && goal.keyResults.length === 3);
+
+    const decomp = await http('POST', `/api/goals/${goal.id}/decompose`);
+    assert.equal(decomp.status, 201);
+    assert.equal(decomp.body.created.length, 3);
+    for (const c of decomp.body.created) {
+      assert.ok(typeof c.task === 'string' && c.task.length > 0);
+      assert.ok(typeof c.kr === 'string' && c.kr.length > 0);
+    }
+
+    // Each KR should now carry a taskId.
+    const after = await http('GET', `/api/goals/${goal.id}`);
+    assert.equal(after.status, 200);
+    assert.ok(after.body.keyResults.every((kr) => Boolean(kr.taskId)));
+  });
+
+  it('rejects decomposition for a goal with no key results', async () => {
+    // Patch the goal to clear its KRs.
+    writeFileSync(progressPath, [
+      '# PROGRESS',
+      '',
+      '## Empty goal',
+      '',
+      'status: active',
+      'progress: 0',
+      '',
+    ].join('\n'), 'utf8');
+
+    const r = await http('POST', '/api/goals/G-empty/decompose');
+    // 404 because the goal id 'G-empty' isn't in the parsed list — fine.
+    assert.ok(r.status === 404 || r.status === 400);
+  });
+
+  it('reverse-sync marks KR done and recomputes progress when task moves to done', async () => {
+    // Decompose first.
+    const goalsList = await http('GET', '/api/goals');
+    const goal = goalsList.body.goals[0];
+    const decomp = await http('POST', `/api/goals/${goal.id}/decompose`);
+    assert.equal(decomp.status, 201);
+    const { task: taskId, kr: krId } = decomp.body.created[0];
+
+    // Mark the task done.
+    const moved = await http('PATCH', `/api/tasks/${taskId}/status`, { status: 'done' });
+    assert.equal(moved.status, 200);
+    assert.equal(moved.body.status, 'done');
+
+    // Goal KR should now be done; progress% should be 1/3.
+    const after = await http('GET', `/api/goals/${goal.id}`);
+    assert.equal(after.status, 200);
+    const kr = after.body.keyResults.find((k) => k.id === krId);
+    assert.equal(kr.done, true);
+    assert.ok(Math.abs(after.body.progress - 1 / 3) < 1e-6);
+
+    // And the PROGRESS.md on disk should reflect the change.
+    const onDisk = readFileSync(progressPath, 'utf8');
+    assert.ok(/progress: 0\.33/.test(onDisk), 'PROGRESS.md progress should be ~0.33');
+  });
+
+  it('does not duplicate tasks on a second decompose call', async () => {
+    const goalsList = await http('GET', '/api/goals');
+    const goal = goalsList.body.goals[0];
+    const first = await http('POST', `/api/goals/${goal.id}/decompose`);
+    assert.equal(first.body.created.length, 3);
+    const second = await http('POST', `/api/goals/${goal.id}/decompose`);
+    // Already-decomposed KRs are skipped, so 0 new tasks.
+    assert.equal(second.body.created.length, 0);
+  });
+});

package/bizar-dash/tests/setup.ts

@@ -13,6 +13,23 @@ if (typeof globalThis.ResizeObserver === 'undefined') {
   } as unknown as typeof ResizeObserver;
 }
 
+// jsdom doesn't ship IntersectionObserver either; SettingsView uses it
+// to sync the left-rail highlight with scroll position. Stub so the
+// effect's `new IntersectionObserver(...)` doesn't throw.
+if (typeof globalThis.IntersectionObserver === 'undefined') {
+  globalThis.IntersectionObserver = class {
+    readonly root: Element | null = null;
+    readonly rootMargin = '';
+    readonly thresholds: ReadonlyArray<number> = [];
+    observe(): void {}
+    unobserve(): void {}
+    disconnect(): void {}
+    takeRecords(): IntersectionObserverEntry[] {
+      return [];
+    }
+  } as unknown as typeof IntersectionObserver;
+}
+
 // Similarly for matchMedia — used by some component libs that the
 // dashboard pulls in. jsdom ships an empty stub but it lacks the
 // addEventListener/removeEventListener pair that React 18 expects.
@@ -32,6 +49,36 @@ if (typeof window !== 'undefined' && !window.matchMedia) {
   });
 }
 
+// jsdom does not implement Element#scrollIntoView, but `cmdk` calls it on
+// the highlighted item during keyboard navigation. Stub a no-op so tests
+// that mount <Dialog><CommandPalette/></Dialog> don't throw.
+if (typeof Element !== 'undefined' && !Element.prototype.scrollIntoView) {
+  Element.prototype.scrollIntoView = function scrollIntoView(): void {
+    /* noop */
+  };
+}
+
+// jsdom doesn't ship EventSource. AgentStreamPanel (Sprint S11) opens
+// an SSE connection on mount, so we stub a no-op stand-in that lets the
+// component subscribe without throwing. Tests that exercise the stream
+// replace globalThis.EventSource with a mock before render.
+if (typeof globalThis.EventSource === 'undefined') {
+  class StubEventSource {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSED = 2;
+    readyState = 0;
+    onopen: ((this: EventSource, ev: Event) => unknown) | null = null;
+    onerror: ((this: EventSource, ev: Event) => unknown) | null = null;
+    onmessage: ((this: EventSource, ev: MessageEvent) => unknown) | null = null;
+    addEventListener(): void {}
+    removeEventListener(): void {}
+    close(): void { this.readyState = 2; }
+    dispatchEvent(): boolean { return true; }
+  }
+  globalThis.EventSource = StubEventSource as unknown as typeof EventSource;
+}
+
 afterEach(() => {
   cleanup();
 });

package/bizar-dash/tests/ui/primitives/VisuallyHidden.test.tsx

@@ -1,27 +1,42 @@
+/**
+ * tests/ui/primitives/VisuallyHidden.test.tsx
+ *
+ * v8 migration — VisuallyHidden test rewritten against the v8 component.
+ *
+ * v7 used class `vh`; v8 uses `v8-visually-hidden`. v8 also exposes
+ * `as` (ElementType) and `forceVisible` props that v7 didn't have.
+ */
 import { describe, it, expect } from 'vitest';
 import { render, screen } from '@testing-library/react';
-import { VisuallyHidden } from '../../../src/web/ui/primitives/VisuallyHidden';
+import { VisuallyHidden } from '../../../src/web/v8/ui/index.js';
 
-describe('VisuallyHidden', () => {
-  it('renders its children inside a span', () => {
+describe('VisuallyHidden (v8)', () => {
+  it('renders its children inside a span by default', () => {
     render(<VisuallyHidden>hidden text</VisuallyHidden>);
     const el = screen.getByText('hidden text');
     expect(el.tagName).toBe('SPAN');
   });
 
-  it('applies the vh class for SR-only styling', () => {
+  it('applies the v8 visually-hidden class for SR-only styling', () => {
     render(<VisuallyHidden>sr-only</VisuallyHidden>);
-    expect(screen.getByText('sr-only')).toHaveClass('vh');
+    expect(screen.getByText('sr-only')).toHaveClass('v8-visually-hidden');
   });
 
-  it('passes additional attributes through to the span', () => {
-    render(
-      <VisuallyHidden id="vh-1" data-testid="vh">
-        x
-      </VisuallyHidden>,
-    );
-    const el = screen.getByTestId('vh');
-    expect(el.id).toBe('vh-1');
-    expect(el).toHaveClass('vh');
+  it('renders as a different element when `as` is provided', () => {
+    render(<VisuallyHidden as="div">label</VisuallyHidden>);
+    expect(screen.getByText('label').tagName).toBe('DIV');
   });
-});
+
+  it('does NOT apply the visually-hidden class when forceVisible is true', () => {
+    render(<VisuallyHidden forceVisible>debug</VisuallyHidden>);
+    const el = screen.getByText('debug');
+    expect(el).not.toHaveClass('v8-visually-hidden');
+  });
+
+  it('appends the user-provided className alongside the v8 class', () => {
+    render(<VisuallyHidden className="extra">label</VisuallyHidden>);
+    const el = screen.getByText('label');
+    expect(el).toHaveClass('v8-visually-hidden');
+    expect(el).toHaveClass('extra');
+  });
+});

package/bizar-dash/vite.config.ts

@@ -14,14 +14,53 @@ export default defineConfig({
     emptyOutDir: true,
     sourcemap: true,
     rollupOptions: {
+      // Single dashboard entry — v8. The legacy v7 (index.html) and v7
+      // mobile (mobile.html) entries were removed in the v8 cutover.
       input: {
-        main: resolve(__dirname, 'src/web/index.html'),
-        mobile: resolve(__dirname, 'src/web/mobile.html'),
+        main: resolve(__dirname, 'src/web/v8.html'),
+      },
+      // Code-split views so the initial bundle only ships what the
+      // Overview needs. Manual chunks are safe in v8 (no shared
+      // legacy state).
+      output: {
+        manualChunks(id) {
+          if (id.includes('/v8/views/')) return 'v8-views';
+          if (id.includes('node_modules/@dnd-kit')) return 'dnd-kit';
+          if (id.includes('node_modules/recharts')) return 'recharts';
+          if (id.includes('node_modules/cmdk')) return 'cmdk';
+          return undefined;
+        },
       },
     },
+    // Lift the chunk-size ceiling for code-split views: a single
+    // kanban view with dnd-kit + recharts is bigger than 500 kB
+    // unminified, but gzip shrinks it well under the warning line.
+    chunkSizeWarningLimit: 800,
+  },
+  define: {
+    // Surfaced via `import.meta.env.VITE_BUILD_SHA` so the sidebar
+    // footer can render the real git SHA instead of "build placeholder".
+    'import.meta.env.VITE_BUILD_SHA': JSON.stringify(
+      process.env['BIZAR_BUILD_SHA'] ?? 'dev',
+    ),
   },
   server: {
     port: 5174,
     strictPort: false,
+    // v8 dashboard calls /api/* and /ws over the browser's same origin
+    // (port 5174). In dev we proxy those to the backend on PORT (4098
+    // by default) so the React app talks to the running server. In prod
+    // the backend serves /api/* itself.
+    proxy: {
+      '/api': {
+        target: process.env.VITE_BACKEND_URL || `http://127.0.0.1:${process.env.PORT || '4098'}`,
+        changeOrigin: true,
+      },
+      '/ws': {
+        target: process.env.VITE_BACKEND_URL || `http://127.0.0.1:${process.env.PORT || '4098'}`,
+        ws: true,
+        changeOrigin: true,
+      },
+    },
   },
 });

package/bizar-dash/vitest.config.ts

@@ -7,9 +7,14 @@ export default defineConfig({
     environment: 'jsdom',
     globals: true,
     setupFiles: ['./tests/setup.ts'],
-    // tests/ is the canonical location; src/web/components/agents/ covers
-    // feature-scoped component tests (e.g. F-035 RoutingDecisions.test.tsx).
-    include: ['tests/**/*.test.{ts,tsx}', 'src/web/components/agents/**/*.test.{ts,tsx}'],
-    exclude: ['tests/**/*.test.mjs'],
+    // The v8 dashboard is the only test surface that ships.
+    include: [
+      'tests/**/*.test.{ts,tsx}',
+      'src/web/v8/**/*.test.{ts,tsx}',
+    ],
+    exclude: [
+      'tests/**/*.test.mjs',
+      'tests/v7-archive/**',
+    ],
   },
 });

package/cli/bin.mjs

@@ -75,6 +75,38 @@ if (
   await ensureSetup({ silent: true });
 }
 
+// ── Build guard (v8.0.2) ─────────────────────────────────────────────────────
+// The dashboard imports `packages/sdk/dist/memory/index.js` and the
+// plugin loader expects `plugins/bizar/dist/index.js`. On a fresh npm
+// install these directories are missing because the tarball ships only
+// TS source. Build them once on entry so `bizar dash start` (and any
+// other subcommand that touches the dashboard) never crashes with
+// `Cannot find module .../packages/sdk/dist/memory/index.js` or
+// `Plugin source not found at .../plugins/bizar`. Both builders are
+// idempotent and skip when dist/ already exists.
+if (
+  !isHelpRequest &&
+  !isVersionRequest &&
+  !process.env.BIZAR_SKIP_BUILD
+) {
+  try {
+    const { buildSdk, buildPlugin } = await import('./provision-claude.mjs');
+    const sdkRes = await buildSdk();
+    if (sdkRes.ok && !sdkRes.skipped) {
+      console.error(chalk.dim(`  → ${sdkRes.message}`));
+    }
+    const plugRes = await buildPlugin();
+    if (plugRes.ok && !plugRes.skipped) {
+      console.error(chalk.dim(`  → ${plugRes.message}`));
+    }
+  } catch (err) {
+    // Best-effort: never abort the user command on a build hiccup.
+    if (process.env.BIZAR_DEBUG) {
+      console.error(chalk.dim(`  [build-guard] ${err.message}`));
+    }
+  }
+}
+
 // ── Banner ─────────────────────────────────────────────────────────────────────
 
 function showBanner() {

package/cli/install.mjs

@@ -1,5 +1,4 @@
 import chalk from 'chalk';
-import boxen from 'boxen';
 import { existsSync, lstatSync, rmSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -114,6 +113,32 @@ export async function installPluginFromGlobal(opts = {}) {
     return false;
   }
 
+  // ── Auto-build: if src exists but dist/ does not, run the tsc build ──
+  // v8.0.2 — fresh npm installs ship only `plugins/bizar/index.ts` and no
+  // compiled entry. The plugin loader previously bailed here with the
+  // misleading "Plugin source not found" message even though the directory
+  // was present; the real blocker was the missing compiled output. Try to
+  // build once before giving up. Best-effort: build failures keep the old
+  // error path (still false return) so the user gets a clear next step.
+  const distEntry = join(pluginPath, 'dist', 'index.js');
+  if (!existsSync(distEntry)) {
+    try {
+      const { buildPlugin } = await import('./provision-claude.mjs');
+      const buildRes = await buildPlugin();
+      if (buildRes.ok && !buildRes.skipped) {
+        console.log(chalk.dim(`    auto-built plugin (${buildRes.message})`));
+      } else if (!buildRes.ok) {
+        console.log(chalk.yellow(`  ⚠ Plugin auto-build failed: ${buildRes.message}`));
+        console.log(chalk.dim('    Run `bizar install` from a checkout, or:'));
+        console.log(chalk.dim('      npx tsc -p plugins/bizar/tsconfig.json'));
+        return false;
+      }
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Plugin auto-build threw: ${err.message}`));
+      return false;
+    }
+  }
+
   await mkdir(destDir, { recursive: true });
 
   async function copyRecursive(srcDir, dstDir) {