hazo_audit 1.0.0

package/CHANGE_LOG.md

@@ -0,0 +1,53 @@
+# Change log
+
+## v1.0.0 — 2026-05-20
+
+Initial release. Implements PRD `design/PRD.md` end-to-end.
+
+### Highlights
+
+- **`wrapWithAudit(adapter)`** — adapter proxy that captures writes to
+  configured tables. Zero source changes to `hazo_connect`. Best-effort:
+  audit failures never break user writes.
+- **`startAuditWorker({ app_adapter })`** — in-process worker that drains
+  the outbox via hazo_connect's `claimRows()`, runs microdiff for JSONB
+  columns, retries with backoff, dead-letters after `max_attempts`.
+- **`createAuditEventsRoutes({ audit_adapter, getAuth })`** — Next.js GET +
+  reveal POST handlers with scope filtering and sensitive-column masking.
+  Reveal is itself audited via an `audit_reveal` intent row.
+- **`<FieldAuditIcon />` + `<FieldAuditTrail />`** — client components.
+  Zero heavy UI deps (no Radix, no hazo_ui peer required).
+- **INI-primary configuration** at `config/hazo_audit_config.ini`. Only TS
+  escape hatch is `resolvers: {...}` on `wrapWithAudit`.
+- **`runWithAuditContext`** — AsyncLocalStorage-backed actor identity.
+- **`createAuditedCrudService`** — drop-in for `createCrudService` plus
+  `{ audit: { before_row, intent_event, intent_payload } }` per-call hints.
+- **`emitIntentEvent`** — direct Layer-1 intent emission.
+- **`bin/hazo-audit-migrate`** — idempotent schema CLI (Postgres + SQLite).
+- **`test-app/`** — Next.js demo: capture, drain, history popover,
+  sensitive masking + reveal, skipped bulk writes, permission toggling.
+
+### Decisions log
+
+22 design decisions from the interview that produced this PRD are captured
+in `design/PRD.md` §16. Notable ones:
+
+- Audit lives in its own package, not in `hazo_connect`.
+- Adapter is wrapped from outside (no producer code changes).
+- INI primary config; the only TS shape is `resolvers`.
+- Default-deny capture with include/exclude prefix + exact name lists.
+- Worker uses `claimRows()` for concurrency safety.
+- Sensitive handling: store raw, mask at read, reveal writes its own intent.
+- R1 supports single-row writes only; bulk + composite PK + non-id WHERE
+  are skipped with a structured warning.
+
+### Known limitations (R1)
+
+See PRD §10 and §15.
+
+- Bulk writes skip by default; opt-in via `fanout_bulk_writes` per table.
+  Pre-write GET fan-out is acknowledged but not implemented in R1.
+- Composite primary keys not supported.
+- `withAudit(name, payload, () => writes)` ergonomic deferred to Phase 2.
+- No standalone worker CLI (`bin/hazo-audit-worker`) yet.
+- No CSV export / cold archival.

package/README.md

@@ -0,0 +1,269 @@
+# hazo_audit
+
+Field-level audit trail for `hazo_connect`-backed apps. Attach to any adapter
+with `wrapWithAudit()` and every write to a captured table auto-produces an
+outbox row, drained by an in-process worker into per-field events the UI can
+render via `<FieldAuditIcon />`.
+
+Zero changes to `hazo_connect`. Zero per-route boilerplate. Add a new
+audited table with an INI block, not a code change.
+
+```
+npm i hazo_audit
+npx hazo-audit-migrate --adapter=pg --connection-string=$DATABASE_URL
+```
+
+## What it does
+
+```ts
+// instrumentation.ts
+import { wrapWithAudit, startAuditWorker } from 'hazo_audit/server'
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup'
+
+const base = getHazoConnectSingleton()
+const adapter = wrapWithAudit(base, { resolvers: { wp: wpResolver } })
+startAuditWorker({ app_adapter: base })
+```
+
+```ts
+// middleware (or request handler)
+import { runWithAuditContext } from 'hazo_audit/server'
+
+await runWithAuditContext(
+  { actor_kind: 'user', actor_user_id: session.user.id, scope_id: session.scope_id },
+  () => next(),
+)
+```
+
+```tsx
+// any field render site
+import { FieldAuditIcon } from 'hazo_audit/client'
+
+<FieldAuditIcon subjectKind="client_folder" subjectId={folder.id} fieldPath="client_name" />
+```
+
+That's it. Insert/update/delete on any `app_*` or `hazo_*` table is captured,
+diffed by microdiff for JSONB columns, and made queryable at `/api/audit/events`.
+
+## Architecture
+
+```
+caller writes
+     │
+     ▼
+wrapWithAudit(adapter)         ─── reads INI ───►  capture decision
+     │                                              ├─ pipeline tables → skip
+     │                                              ├─ exclude_* matches → skip
+     │                                              ├─ include_* matches → capture
+     │                                              └─ default → skip
+     │
+     ▼ (captured)
+hazo_audit_outbox  ◄────────────  claimRows()  ────► startAuditWorker
+     │
+     │ worker resolves before_row (caller hint, or chain prior outbox)
+     │ microdiff(before, after) for JSONB columns
+     │
+     ▼
+hazo_audit_field  ◄────────────  /api/audit/events  ────► <FieldAuditTrail>
+                                                          (scope filter, mask sensitive)
+```
+
+## Entries
+
+| Import | What |
+|---|---|
+| `hazo_audit` | Client-safe types and permission constants (`AUDIT_VIEW_HISTORY`, etc.). |
+| `hazo_audit/server` | `wrapWithAudit`, `startAuditWorker`, `runWithAuditContext`, `createAuditedCrudService`, `emitIntentEvent`. Server-only. |
+| `hazo_audit/nextjs` | `createAuditEventsRoutes` — Next.js GET + reveal POST handlers. |
+| `hazo_audit/client` | `<FieldAuditIcon />`, `<FieldAuditTrail />`. Safe in client components. |
+
+### Tailwind v4 setup (required for the client components)
+
+The client components use Tailwind utility classes. With Tailwind v4's JIT,
+classes inside `node_modules/` are invisible unless you opt in. Add this to
+your `globals.css` (or wherever you `@import "tailwindcss";`):
+
+```css
+@import "tailwindcss";
+@source "../node_modules/hazo_audit/dist";
+```
+
+Without the `@source` line, the popover and trail will render without
+styling.
+
+## Capture rules — `config/hazo_audit_config.ini`
+
+INI is the **primary** source of truth. The only TypeScript escape hatch is
+`resolvers: {...}` on `wrapWithAudit` (for project-specific JSONB path
+canonicalisation).
+
+```ini
+[capture]
+include_table_prefixes = app_, hazo_
+exclude_table_prefixes = _
+exclude_tables = hazo_chat_typing_indicators
+
+[overrides.app_clients]
+subject_kind = client
+sensitive_columns = ssn, dob
+
+[overrides.app_client_folders]
+subject_kind = client_folder
+jsonb_columns = working_paper
+jsonb_path_exclude = working_paper.__prefill_data
+resolver = wp
+```
+
+Capture decision (deterministic, PRD §6.1): pipeline tables → exclude →
+include → default deny.
+
+## Public API (R1)
+
+### `wrapWithAudit(adapter, opts?)` → `HazoConnectAdapter`
+
+Proxies `query()` and `claimRows()`. For writes to captured tables, enqueues
+an outbox row after the underlying call succeeds. Best-effort: any audit
+failure fires `opts.onAuditFailure(err, ctx)` but never throws into the user
+write path.
+
+```ts
+wrapWithAudit(base, {
+  resolvers: { wp: wpResolver },
+  onAuditFailure: (err, ctx) => log.error('audit_failed', { ...ctx, err }),
+})
+```
+
+### `startAuditWorker({ app_adapter, ... })` → `WorkerHandle`
+
+Drains the outbox via `claimRows()` (concurrency-safe), runs microdiff,
+inserts field events, and dead-letters after `max_attempts` failures.
+
+```ts
+const worker = startAuditWorker({ app_adapter: base, poll_ms: 2000 })
+// later
+await worker.stop()
+// or for tests
+const { processed, failed } = await worker.drainOnce()
+```
+
+### `runWithAuditContext(ctx, fn)`
+
+AsyncLocalStorage-backed actor identity. The wrap stamps these fields onto
+each outbox row. Missing context → `actor_kind: 'background_job'`.
+
+### `createAuditedCrudService(adapter, table)` → `AuditedCrudService<T>`
+
+Drop-in for `hazo_connect`'s `createCrudService` plus an `opts.audit` hook
+for supplying `before_row` (so the worker doesn't have to chain) and
+piggybacking a Layer-1 `intent_event` onto the write.
+
+```ts
+await svc.updateById(folderId, patch, {
+  audit: {
+    before_row: previousRow,
+    intent_event: 'folder_field_edited',
+    intent_payload: { field: 'client_name' },
+  },
+})
+```
+
+### `emitIntentEvent({ event_name, payload?, subject_kind?, subject_id? })`
+
+Direct Layer-1 intent emission (no piggyback). `withAudit(name, payload, fn)`
+ergonomic is Phase 2.
+
+### `createAuditEventsRoutes({ audit_adapter, getAuth })` → `{ GET, reveal: { POST } }`
+
+Next.js route factory.
+
+- `GET /api/audit/events` — requires `view_audit_history`. Default-filters
+  by caller's `scope_id` unless they hold `view_audit_across_scopes`.
+  Sensitive rows' values masked to `null` unless caller holds
+  `view_sensitive_audit`.
+- `POST /api/audit/events/[id]/reveal` — additionally requires
+  `view_sensitive_audit`. Side effect: writes an `audit_reveal` intent row.
+
+```ts
+createAuditEventsRoutes({
+  audit_adapter,
+  getAuth: async (req) => {
+    const a = await hazo_get_tenant_auth(req)
+    if (!a.authenticated) return null
+    return {
+      user_id: a.user.id,
+      scope_id: a.selected_scope_id,
+      permissions: a.permissions,
+      user_label: a.user.full_name,
+    }
+  },
+})
+```
+
+### `<FieldAuditIcon subjectKind subjectId fieldPath />`
+
+Renders a clock icon that opens a popover with the field's audit trail.
+Self-positioning, no Radix dep.
+
+### `<FieldAuditTrail subjectKind subjectId fieldPath? />`
+
+Renders the trail directly (use in a sidebar, modal, etc.).
+
+## Schema
+
+Three tables (see `migrations/001_init.sql` for both Postgres + SQLite):
+
+- `hazo_audit_outbox` — pre-drain queue.
+- `hazo_audit_field` — per-leaf field events (UI reads from this).
+- `hazo_audit_intent` — Layer-1 named events.
+
+## CLI — `hazo-audit-migrate`
+
+```bash
+npx hazo-audit-migrate --adapter=pg     --connection-string=$DATABASE_URL
+npx hazo-audit-migrate --adapter=sqlite --path=./data/app.db
+npx hazo-audit-migrate --adapter=pg     --connection-string=$DATABASE_URL --dry-run
+```
+
+PostgREST cannot run DDL; use `--adapter=pg` against the same Postgres
+instance.
+
+## Limitations (R1)
+
+| Shape | Behavior |
+|---|---|
+| Single-row insert/update/delete with eq-on-id WHERE | ✅ captured |
+| Bulk insert | skipped + warning (opt-in `fanout_bulk_writes`) |
+| Bulk update / delete (non-id WHERE) | skipped + warning |
+| Composite primary key | skipped + warning (Phase 2) |
+| Insert without `Prefer: return=representation` | skipped + warning |
+| Raw writes (`adapter.rawQuery`) | pass-through, never audited |
+
+See PRD §15 for the deferred-feature list.
+
+## Test-app
+
+The `test-app/` directory contains a Next.js demo:
+
+```bash
+npm run dev:test-app   # http://localhost:3017
+```
+
+Sidebar walks through:
+
+- Capture & Drain — insert/update/delete a client, watch the outbox grow.
+- Worker — manual `drainOnce()`, see field events appear, retry counts.
+- History UI — `<FieldAuditIcon />` and `<FieldAuditTrail />` in action.
+- Sensitive + Reveal — SSN masking and the reveal-is-itself-audited flow.
+- Skipped Writes — bulk inserts that get skipped with a warning.
+- Permissions — toggle cookies to exercise 401/403/masking.
+
+Backed by SQLite (sql.js); the demo DB lives at `test-app/data/demo.db`.
+
+## Related
+
+- `hazo_connect` — provides the adapter interface and `claimRows()` primitive.
+- `hazo_auth` — typical source of session + permissions for `getAuth`.
+- `hazo_collab_forms@5.10.0+` — auto-wires `<FieldAuditIcon />` via
+  `field_audit` prop.
+
+See `design/PRD.md` for the full design rationale and decision log.

package/SETUP_CHECKLIST.md

@@ -0,0 +1,186 @@
+# SETUP_CHECKLIST — `hazo_audit`
+
+Step-by-step setup for a consuming app. Assumes `hazo_connect` is already
+configured.
+
+## 1. Install
+
+```bash
+npm i hazo_audit
+```
+
+Optional but typical peers:
+
+```bash
+npm i hazo_auth          # session + permissions for the routes
+```
+
+## 2. Apply the schema
+
+Choose the adapter that matches your production DB. PostgREST users still
+need a direct Postgres connection for DDL — point `--connection-string` at
+the underlying Postgres URL.
+
+```bash
+# Postgres
+npx hazo-audit-migrate --adapter=pg --connection-string=$DATABASE_URL
+
+# SQLite (local dev)
+npx hazo-audit-migrate --adapter=sqlite --path=./data/app.db
+```
+
+Adds three tables: `hazo_audit_outbox`, `hazo_audit_field`,
+`hazo_audit_intent`. Idempotent — safe to re-run.
+
+## 3. Drop in the capture config
+
+```bash
+mkdir -p config
+cp node_modules/hazo_audit/config/hazo_audit_config.ini.sample config/hazo_audit_config.ini
+```
+
+Edit to taste. Defaults capture every `app_*` and `hazo_*` table except
+pipeline tables. Per-table overrides for `sensitive_columns`,
+`jsonb_columns`, and resolvers go here too.
+
+## 4. Wrap your adapter (`instrumentation.ts`)
+
+```ts
+// instrumentation.ts
+import { wrapWithAudit, startAuditWorker } from 'hazo_audit/server'
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup'
+
+let registered = false
+
+export function register() {
+  if (registered) return
+  registered = true
+  const base = getHazoConnectSingleton()
+  const adapter = wrapWithAudit(base, {
+    resolvers: { /* wp: wpResolver, ... */ },
+    onAuditFailure: (err, ctx) => console.error('[audit]', ctx, err.message),
+  })
+  // Export `adapter` instead of `base` from wherever your app gets its adapter.
+  ;(globalThis as any).__hazo_adapter = adapter
+  startAuditWorker({ app_adapter: base })
+}
+```
+
+Make sure your app imports the **wrapped** adapter (the one returned by
+`wrapWithAudit`) wherever it would have imported the base adapter. The
+worker uses the base adapter (the wrap is not needed for outbox drain).
+
+## 5. Stamp actor context per request
+
+```ts
+// middleware.ts (or your auth wrapper)
+import { runWithAuditContext } from 'hazo_audit/server'
+
+await runWithAuditContext(
+  {
+    actor_kind: 'user',
+    actor_user_id: session.user.id,
+    actor_label: session.user.full_name,
+    scope_id: session.scope_id,
+  },
+  () => handler(),
+)
+```
+
+Without this, every captured write defaults to
+`actor_kind: 'background_job'`.
+
+## 6. Mount the routes (Next.js App Router)
+
+```ts
+// app/api/audit/events/route.ts
+import { createAuditEventsRoutes } from 'hazo_audit/nextjs'
+import { hazo_get_tenant_auth } from 'hazo_auth/lib/auth/hazo_get_tenant_auth.server'
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup'
+
+const routes = createAuditEventsRoutes({
+  audit_adapter: getHazoConnectSingleton(),
+  getAuth: async (req) => {
+    const a = await hazo_get_tenant_auth(req as any)
+    if (!a.authenticated) return null
+    return {
+      user_id: a.user.id,
+      scope_id: a.selected_scope_id,
+      permissions: a.permissions,
+      user_label: a.user.full_name,
+    }
+  },
+})
+
+export const GET = routes.GET
+```
+
+```ts
+// app/api/audit/events/[id]/reveal/route.ts
+import { /* same as above */ } from '...'
+
+const routes = createAuditEventsRoutes(/* same opts */)
+
+export const POST = routes.reveal.POST
+```
+
+## 7. Grant the audit permissions
+
+The routes check three permission strings (constants exported from
+`hazo_audit`):
+
+| Constant | Effect when missing |
+|---|---|
+| `view_audit_history` | 403 on `/audit/events` and `/reveal`. |
+| `view_sensitive_audit` | Sensitive `before_value`/`after_value` returned as `null`. `/reveal` 403. |
+| `view_audit_across_scopes` | Results filtered to caller's `scope_id`. |
+
+Assign via your hazo_auth role config (e.g.
+`hazo_auth/role_permissions.json`).
+
+## 8. Render the UI
+
+Either inline:
+
+```tsx
+import { FieldAuditIcon } from 'hazo_audit/client'
+
+<FieldAuditIcon subjectKind="client_folder" subjectId={folder.id} fieldPath="client_name" />
+```
+
+…or via `hazo_collab_forms@5.10.0+`:
+
+```tsx
+<HazoDataForm
+  field_audit={{ subjectKind: 'client_folder', subjectId: folder.id }}
+  {/* ... */}
+/>
+```
+
+`hazo_collab_forms` injects the icon into
+`field_action_components.row_end` for every field.
+
+## 9. Smoke test
+
+1. Edit any field that lands in a captured table.
+2. Check `hazo_audit_outbox` — should have one row with your write.
+3. Wait ~3s (or the configured `worker.poll_ms`) for drain.
+4. Check `hazo_audit_field` — should have one row per changed scalar / JSONB
+   leaf.
+5. Hit `/api/audit/events?subject_kind=...&subject_id=...` — should return
+   the field events with `actor_user_id` set to the logged-in user.
+6. Click the field's audit icon — popover shows the history.
+
+If the popover is empty for a known-captured field, check the dev console
+for `audit.skipped_unsupported_shape` warnings (most common cause: the
+adapter didn't return rows on insert because `Prefer: return=representation`
+wasn't set).
+
+## 10. Tune the INI (optional)
+
+| Section | What to consider |
+|---|---|
+| `[capture]` | Add `include_tables` for any table not matching a prefix; `exclude_tables` for noisy ones. |
+| `[retention]` | Default 30d for drained outbox, 90d for dead-lettered. Bump if you need longer auditability. |
+| `[worker]` | Bump `poll_ms` down for snappier history (CPU cost: minimal at single-pod scale). |
+| `[overrides.<table>]` | `sensitive_columns`, `jsonb_columns`, `jsonb_path_exclude`, `resolver`, `fanout_bulk_writes`. |

package/bin/hazo-audit-migrate.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+/**
+ * hazo-audit-migrate
+ *
+ * Idempotently applies the hazo_audit schema migrations to a configured
+ * database. Reads connection info from CLI flags or env vars.
+ *
+ * Usage:
+ *   npx hazo-audit-migrate --adapter=pg --connection-string=$DATABASE_URL
+ *   npx hazo-audit-migrate --adapter=sqlite --path=./data/app.db
+ *
+ * Env vars (used when flags omitted):
+ *   DATABASE_URL                       (pg)
+ *   SQLITE_PATH                        (sqlite)
+ */
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MIGRATION_FILE = resolve(__dirname, '../migrations/001_init.sql');
+
+function parseArgs(argv) {
+  const out = {};
+  for (const arg of argv) {
+    if (!arg.startsWith('--')) continue;
+    const eq = arg.indexOf('=');
+    if (eq === -1) {
+      out[arg.slice(2)] = true;
+    } else {
+      out[arg.slice(2, eq)] = arg.slice(eq + 1);
+    }
+  }
+  return out;
+}
+
+function help() {
+  console.error(`hazo-audit-migrate — apply hazo_audit schema migrations.
+
+Usage:
+  hazo-audit-migrate --adapter=<pg|sqlite> [flags...]
+
+Adapters:
+  --adapter=pg        --connection-string=URL
+  --adapter=sqlite    --path=FILE
+
+Other:
+  --sql=FILE          Override the SQL file (defaults to bundled 001_init.sql).
+  --dry-run           Print SQL without applying.
+
+Note: PostgREST cannot run DDL; use --adapter=pg pointed at the same Postgres
+instance to apply migrations, then point your app at PostgREST as usual.
+`);
+}
+
+function splitStatements(sql) {
+  const lines = sql.split('\n').filter((l) => !l.trim().startsWith('--'));
+  const joined = lines.join('\n');
+  return joined
+    .split(/;\s*(?:\r?\n|$)/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+}
+
+async function runPg(args, statements) {
+  const connStr = args['connection-string'] || process.env.DATABASE_URL;
+  if (!connStr) {
+    throw new Error('pg: --connection-string=... or DATABASE_URL required');
+  }
+  const mod = await import('postgres').catch(() => {
+    throw new Error(
+      'pg adapter needs the `postgres` npm package. Install in your app: `npm i postgres`.',
+    );
+  });
+  const sql = mod.default(connStr);
+  try {
+    for (const stmt of statements) {
+      await sql.unsafe(stmt);
+    }
+    console.log(`Applied ${statements.length} statement(s).`);
+  } finally {
+    await sql.end({ timeout: 5 });
+  }
+}
+
+async function runSqlite(args) {
+  const path = args.path || process.env.SQLITE_PATH;
+  if (!path) throw new Error('sqlite: --path=... or SQLITE_PATH required');
+  const mod = await import('better-sqlite3').catch(() => {
+    throw new Error(
+      'sqlite adapter needs `better-sqlite3`. Install in your app: `npm i better-sqlite3`.',
+    );
+  });
+  const Database = mod.default;
+  const db = new Database(path);
+  try {
+    const sqliteStatements = extractSqliteBlock(
+      readFileSync(MIGRATION_FILE, 'utf-8'),
+    );
+    const tx = db.transaction(() => {
+      for (const stmt of sqliteStatements) {
+        db.prepare(stmt).run();
+      }
+    });
+    tx();
+    console.log(
+      `Applied ${sqliteStatements.length} SQLite statement(s) to ${path}.`,
+    );
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Extract the commented SQLite block from the bundled SQL, stripping the
+ * leading "-- " from each line.
+ */
+function extractSqliteBlock(sql) {
+  const start = sql.indexOf('-- SQLite version');
+  const end = sql.indexOf('-- PostgreSQL version');
+  if (start === -1 || end === -1) return [];
+  const block = sql
+    .slice(start, end)
+    .split('\n')
+    .map((l) => l.replace(/^-- ?/, '').trim())
+    .filter((l) => l.length > 0 && !l.startsWith('SQLite version'))
+    .join('\n');
+  return splitStatements(block);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help || args.h) {
+    help();
+    process.exit(0);
+  }
+  const adapter = args.adapter;
+  if (!adapter) {
+    help();
+    process.exit(1);
+  }
+
+  if (args['dry-run']) {
+    const sqlFile = args.sql ? resolve(process.cwd(), args.sql) : MIGRATION_FILE;
+    const sql = readFileSync(sqlFile, 'utf-8');
+    const statements =
+      adapter === 'sqlite' ? extractSqliteBlock(sql) : splitStatements(sql);
+    console.log(`-- Would apply ${statements.length} statement(s) from ${sqlFile}:`);
+    for (const [i, s] of statements.entries()) {
+      console.log(`-- [${i + 1}/${statements.length}]`);
+      console.log(s + ';');
+    }
+    return;
+  }
+
+  if (adapter === 'pg') {
+    const sqlFile = args.sql ? resolve(process.cwd(), args.sql) : MIGRATION_FILE;
+    const sql = readFileSync(sqlFile, 'utf-8');
+    return runPg(args, splitStatements(sql));
+  }
+  if (adapter === 'sqlite') return runSqlite(args);
+  throw new Error(`Unknown adapter: ${adapter}`);
+}
+
+main().catch((err) => {
+  console.error('hazo-audit-migrate failed:', err.message);
+  process.exit(1);
+});