cvx-kit 0.0.8 → 0.1.1

package/docs/webhooks.md

@@ -0,0 +1,58 @@
+# `cvx-kit/webhooks` — the sanctioned webhook boundary
+
+Webhooks are the one boundary that genuinely needs deduplication (Convex's
+client gives exactly-once for its own mutations; external providers redeliver).
+The helper encodes the pattern: **verify over the raw body (fail closed) →
+derive the natural key → delegate to an internal mutation whose first act is
+transactional dedup**.
+
+## Wiring
+
+```ts
+// schema — host-owned dedup table (the kit gains no tables):
+webhookEvents: webhookEventsTable().table.index('by_eventKey', ['eventKey'])
+
+// boundary — used inside the host's httpAction:
+const boundary = createWebhookBoundary({
+  // RAW body, BEFORE parsing. Constant-time comparison (crypto.subtle HMAC
+  // verify), secret from a Convex environment variable — never in code.
+  verify: async (raw, request) => verifyVendorSignature(raw, request.headers),
+  // The natural-key pattern:
+  eventKey: (raw) => {
+    const event = JSON.parse(raw)
+    return `${event.type}:${event.id}:${event.updatedAt}`
+  },
+  source: 'vendor',
+})
+
+// http.ts — routing only:
+http.route({ path: '/webhooks/vendor', method: 'POST',
+  handler: httpAction((ctx, request) =>
+    boundary.handle(ctx, request, internal.<module>.functions.applyVendorEvent)) })
+
+// the target — a systemMutation; dedup FIRST, transactionally:
+export const applyVendorEvent = systemMutation({
+  args: { eventKey: z.string(), payload: z.string(), source: z.string() },
+  handler: async (ctx, args) => {
+    const { duplicate } = await recordWebhookEvent(ctx, { key: args.eventKey, source: args.source })
+    if (duplicate) return null
+    const payload = JSON.parse(args.payload)   // parse INSIDE the trusted path
+    // ...apply, via domain executors
+    return null
+  },
+})
+```
+
+## Rules
+
+1. **Dedup lives in the mutation, never the action.** The action can race;
+   the mutation's insert-if-absent is transactional.
+2. **Verification is over raw bytes.** Re-serialized/parsed bodies break or
+   weaken HMACs; the helper hands `verify` the raw `request.text()`.
+3. **Fail closed.** `verify` returning false OR throwing both reject with
+   `WEBHOOK_SIGNATURE_INVALID`, before any delegation.
+4. **Retention is yours.** Dedup rows grow forever unless pruned — run a
+   cleanup cron over `receivedAt` with a window comfortably longer than the
+   provider's redelivery horizon (days, not hours).
+5. Providers with signed timestamps (Stripe-style): also enforce a tolerance
+   window inside `verify`.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cvx-kit",
-	"version": "0.0.8",
+	"version": "0.1.1",
 	"description": "Reusable Convex application kit: foundation kernels, approvals component, zod table boundaries, WorkOS-backed auth function constructors, and audited command protocol.",
 	"type": "module",
 	"license": "MIT",
@@ -23,6 +23,26 @@
 			"types": "./dist/tenancy.d.mts",
 			"import": "./dist/tenancy.mjs"
 		},
+		"./state-machine": {
+			"types": "./dist/state-machine.d.mts",
+			"import": "./dist/state-machine.mjs"
+		},
+		"./crud": {
+			"types": "./dist/crud.d.mts",
+			"import": "./dist/crud.mjs"
+		},
+		"./middleware": {
+			"types": "./dist/middleware.d.mts",
+			"import": "./dist/middleware.mjs"
+		},
+		"./webhooks": {
+			"types": "./dist/webhooks.d.mts",
+			"import": "./dist/webhooks.mjs"
+		},
+		"./agent-tools": {
+			"types": "./dist/agent-tools.d.mts",
+			"import": "./dist/agent-tools.mjs"
+		},
 		"./triggers": {
 			"types": "./dist/triggers.d.mts",
 			"import": "./dist/triggers.mjs"
@@ -70,7 +90,10 @@
 	"scripts": {
 		"build": "vp pack && node scripts/convex-config-bridge.mjs && publint",
 		"typecheck": "tsc --noEmit",
-		"test": "vp test run",
+		"test": "vp test run --exclude test/package-contents.test.mjs",
+		"test:package": "bun run build && vp test run test/package-contents.test.mjs",
+		"test:package:smoke:bun": "bun scripts/smoke-packed-components.mjs bun",
+		"test:package:smoke:npm": "node scripts/smoke-packed-components.mjs npm",
 		"docs:sync": "rm -f docs/*.md && cp src/docs/*.md docs/",
 		"prepublishOnly": "bun run build && bun run typecheck && bun run test && bun run docs:sync",
 		"build:codegen": "convex codegen --component-dir ./src/components/foundation && convex codegen --component-dir ./src/components/approvals && vp pack",

package/scripts/convex-config-bridge.mjs

@@ -2,7 +2,13 @@
 // is literally named `convex.config.js` (see DEFINITION_FILENAME_JS in the
 // convex CLI). vp pack emits .mjs, so this postbuild step materializes the
 // compiled definition as convex.config.js in each component's dist directory.
-import { readFileSync, writeFileSync } from 'node:fs'
+import {
+	readFileSync,
+	readdirSync,
+	renameSync,
+	rmSync,
+	writeFileSync,
+} from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
@@ -10,8 +16,40 @@ const root = join(dirname(fileURLToPath(import.meta.url)), '..')
 
 for (const component of ['foundation', 'approvals']) {
 	const directory = join(root, 'dist', 'components', component)
-	const compiled = readFileSync(join(directory, 'convex.config.mjs'), 'utf8')
+	const config = readFileSync(join(directory, 'convex.config.mjs'), 'utf8')
 		.replace(/\/\/# sourceMappingURL=.*\n?/, '')
-	writeFileSync(join(directory, 'convex.config.js'), compiled)
+	writeFileSync(join(directory, 'convex.config.js'), config)
+
+	// Component implementations are discovered from schema.ts/schema.js only.
+	// Keeping schema.mjs beside schema.js is also invalid because Convex
+	// canonicalizes both extensions to the same module path.
+	const schema = readFileSync(join(directory, 'schema.mjs'), 'utf8').replace(
+		/\/\/# sourceMappingURL=.*\n?/,
+		'',
+	)
+	writeFileSync(join(directory, 'schema.js'), schema)
+	for (const filename of readdirSync(directory)) {
+		if (!filename.endsWith('.mjs')) continue
+		const path = join(directory, filename)
+		const source = readFileSync(path, 'utf8')
+		const bridged = source.replaceAll('./schema.mjs', './schema.js')
+		if (bridged !== source) writeFileSync(path, bridged)
+	}
+	renameSync(join(directory, 'schema.d.mts'), join(directory, 'schema.d.ts'))
+	const dataModelDeclaration = join(
+		directory,
+		'_generated',
+		'dataModel.d.mts',
+	)
+	writeFileSync(
+		dataModelDeclaration,
+		readFileSync(dataModelDeclaration, 'utf8').replace(
+			'../schema.mjs',
+			'../schema.js',
+		),
+	)
+	rmSync(join(directory, 'schema.mjs'))
+	rmSync(join(directory, 'schema.mjs.map'))
 	console.log(`bridged dist/components/${component}/convex.config.js`)
+	console.log(`bridged dist/components/${component}/schema.js`)
 }

package/scripts/extract-changelog.mjs

@@ -0,0 +1,29 @@
+// Extracts one version's section from CHANGELOG.md (Keep a Changelog form).
+// Usage: node scripts/extract-changelog.mjs 0.1.0 [outfile]
+// Used by the release workflow for GitHub Release notes, and runnable
+// locally BEFORE tagging to verify extraction (see the release plan).
+import { readFileSync, writeFileSync } from 'node:fs'
+
+const version = process.argv[2]
+if (!version) {
+	console.error('usage: extract-changelog.mjs <version> [outfile]')
+	process.exit(1)
+}
+const changelog = readFileSync(new URL('../CHANGELOG.md', import.meta.url), 'utf8')
+const pattern = new RegExp(
+	String.raw`^## \[${version.replace(/\./g, String.raw`\.`)}\][^\n]*\n([\s\S]*?)(?=^## \[|\Z)`,
+	'm',
+)
+const match = changelog.match(pattern)
+if (!match) {
+	console.error(`CHANGELOG.md has no section for version ${version}`)
+	process.exit(1)
+}
+const notes = match[1].trim()
+if (!notes) {
+	console.error(`CHANGELOG.md section for ${version} is empty`)
+	process.exit(1)
+}
+const outfile = process.argv[3]
+if (outfile) writeFileSync(outfile, `${notes}\n`)
+else process.stdout.write(`${notes}\n`)

package/scripts/smoke-packed-components.mjs

@@ -0,0 +1,374 @@
+import { execFileSync } from 'node:child_process'
+import {
+	copyFileSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const installer = process.argv[2] ?? 'bun'
+if (installer !== 'bun' && installer !== 'npm') {
+	throw new Error('Usage: smoke-packed-components.mjs [bun|npm]')
+}
+
+const root = join(import.meta.dirname, '..')
+const temporaryRoot = mkdtempSync(join(tmpdir(), 'cvx-kit-smoke-'))
+const fixture = join(temporaryRoot, 'fixture')
+const packageVersion = JSON.parse(
+	readFileSync(join(root, 'package.json'), 'utf8'),
+).version
+const tarball = join(temporaryRoot, `cvx-kit-${packageVersion}.tgz`)
+
+function run(command, args, cwd = fixture) {
+	return execFileSync(command, args, {
+		cwd,
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'pipe'],
+		env: { ...process.env, CONVEX_AGENT_MODE: 'anonymous' },
+	})
+}
+
+function runStreaming(command, args, cwd = fixture) {
+	execFileSync(command, args, {
+		cwd,
+		stdio: 'inherit',
+		env: { ...process.env, CONVEX_AGENT_MODE: 'anonymous' },
+	})
+}
+
+function runConvex(...args) {
+	return run('node', [
+		join(fixture, 'node_modules', 'convex', 'bin', 'main.js'),
+		...args,
+	])
+}
+
+function write(relativePath, contents) {
+	const path = join(fixture, relativePath)
+	writeFileSync(path, contents)
+}
+
+function step(label, callback) {
+	console.log(`smoke step: ${label}`)
+	return callback()
+}
+
+try {
+	run(
+		'bun',
+		['pm', 'pack', '--destination', temporaryRoot, '--ignore-scripts'],
+		root,
+	)
+	mkdirSync(join(fixture, 'convex'), { recursive: true })
+	write(
+		'package.json',
+		JSON.stringify(
+			{
+				private: true,
+				type: 'module',
+				dependencies: {
+					'cvx-kit': `file:${tarball}`,
+					convex: '1.43.0',
+					zod: '4.4.3',
+				},
+				devDependencies: {
+					'vite-plus': '0.2.8',
+				},
+			},
+			null,
+			2,
+		),
+	)
+	write(
+		'packed-test-helper.test.ts',
+		`import { describe, expect, it } from 'vite-plus/test'
+import { registerApprovals, registerFoundation } from 'cvx-kit/test'
+
+describe('packed cvx-kit test helpers', () => {
+  it('registers both compiled component bundles and their discoverable schemas', () => {
+    const registrations = []
+    const testRuntime = {
+      registerComponent(name, schema, modules) {
+        registrations.push({ name, schema, modules })
+      },
+    }
+
+    registerApprovals(testRuntime)
+    registerFoundation(testRuntime)
+
+    expect(registrations.map(({ name }) => name)).toEqual(['approvals', 'foundation'])
+    expect(Object.keys(registrations[0].schema.tables).sort()).toEqual([
+      'approvalDecisions',
+      'approvalRuns',
+    ])
+    expect(Object.keys(registrations[0].modules)).toContain(
+      '../dist/components/approvals/health.mjs',
+    )
+  })
+})
+`,
+	)
+	write(
+		'convex/convex.config.ts',
+		`import { defineApp } from 'convex/server'
+import approvals from 'cvx-kit/components/approvals/convex.config'
+import foundation from 'cvx-kit/components/foundation/convex.config'
+
+const app = defineApp()
+app.use(approvals)
+app.use(foundation)
+export default app
+`,
+	)
+	write(
+		'convex/smoke.ts',
+		`import { approvalCallbackArgs } from 'cvx-kit/components/approvals'
+import { createFunctionHandle, paginationOptsValidator } from 'convex/server'
+import { v } from 'convex/values'
+import { components, internal } from './_generated/api'
+import { internalMutation, mutation, query } from './_generated/server'
+
+export const applyDecision = internalMutation({
+  args: approvalCallbackArgs,
+  returns: v.null(),
+  handler: (_ctx, input) => {
+    if (input.decision?.evidence[0]?.stepKey !== 'releaseDecision') {
+      throw new Error('Missing callback decision step key')
+    }
+    return null
+  },
+})
+
+export const rejectDecision = internalMutation({
+  args: approvalCallbackArgs,
+  returns: v.null(),
+  handler: () => null,
+})
+
+export const health = query({
+  args: {},
+  returns: v.any(),
+  handler: (ctx) => ctx.runQuery(components.approvals.health.check, {}),
+})
+
+export const foundationHealth = query({
+  args: {},
+  returns: v.literal('ready'),
+  handler: (ctx) => ctx.runQuery(components.foundation.functions.status, {}),
+})
+
+export const start = mutation({
+  args: { resourceRef: v.optional(v.string()) },
+  returns: v.object({ runId: v.string() }),
+  handler: async (ctx, args) => {
+    const approvedHandle = await createFunctionHandle(internal.smoke.applyDecision)
+    const rejectedHandle = await createFunctionHandle(internal.smoke.rejectDecision)
+    return ctx.runMutation(components.approvals.requests.start, {
+      scopeRef: 'smoke',
+      resourceType: 'release',
+      resourceRef: args.resourceRef ?? 'packed-component',
+      requester: { actorRef: 'requester', capabilities: [] },
+      workflow: {
+        schemaVersion: 1,
+        compatibilityKey: 'packedSmoke',
+        name: 'packedSmoke',
+        steps: [
+          {
+            kind: 'decision',
+            key: 'releaseDecision',
+            decisions: ['approved', 'rejected'],
+            quorum: { kind: 'count', approvals: 1 },
+            makerChecker: true,
+          },
+          {
+            kind: 'branch',
+            key: 'routeDecision',
+            approvedStepKey: 'applyDecision',
+            rejectedStepKey: 'rejectDecision',
+          },
+          {
+            kind: 'mutation',
+            key: 'applyDecision',
+            callback: { kind: 'mutation', handle: approvedHandle, retry: false },
+          },
+          {
+            kind: 'mutation',
+            key: 'rejectDecision',
+            callback: { kind: 'mutation', handle: rejectedHandle, retry: false },
+          },
+        ],
+      },
+    })
+  },
+})
+
+export const list = query({
+  args: {
+    paginationOpts: paginationOptsValidator,
+    state: v.optional(v.union(v.literal('pending'), v.literal('approved'))),
+  },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runQuery(components.approvals.requests.list, {
+    scopeRef: 'smoke',
+    ...args,
+  }),
+})
+
+export const decide = mutation({
+  args: { runId: v.string() },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runMutation(components.approvals.decisions.decide, {
+    runId: args.runId,
+    decision: 'approved',
+    actor: { actorRef: 'approver', capabilities: [] },
+    compatibilityKey: 'packedSmoke',
+  }),
+})
+
+export const history = query({
+  args: { runId: v.string() },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runQuery(components.approvals.decisions.list, args),
+})
+
+export const status = query({
+  args: { runId: v.string() },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runQuery(components.approvals.requests.status, {
+    ...args,
+    compatibilityKey: 'packedSmoke',
+  }),
+})
+`,
+	)
+
+	if (installer === 'bun') {
+		copyFileSync(join(root, 'bun.lock'), join(fixture, 'bun.lock'))
+	}
+	if (installer === 'bun')
+		step('install with bun', () =>
+			runStreaming('bun', ['install', '--ignore-scripts']),
+		)
+	else
+		step('install with npm', () =>
+			runStreaming('npm', ['install', '--ignore-scripts']),
+		)
+	if (installer === 'bun')
+		step('test helper with bun', () =>
+			runStreaming('bunx', ['vp', 'test', 'run', 'packed-test-helper.test.ts']),
+		)
+	else
+		step('test helper with npm', () =>
+			runStreaming('npx', ['vp', 'test', 'run', 'packed-test-helper.test.ts']),
+		)
+
+	step('deploy Convex fixture', () =>
+		runConvex('dev', '--once', '--typecheck=disable'),
+	)
+	const health = JSON.parse(runConvex('run', 'smoke:health'))
+	if (health.status !== 'ready' || health.schemaVersion !== 1) {
+		throw new Error(
+			`Unexpected approvals health response: ${JSON.stringify(health)}`,
+		)
+	}
+	const foundationHealth = JSON.parse(
+		runConvex('run', 'smoke:foundationHealth'),
+	)
+	if (foundationHealth !== 'ready') {
+		throw new Error(
+			`Unexpected foundation health response: ${JSON.stringify(foundationHealth)}`,
+		)
+	}
+	const { runId } = JSON.parse(runConvex('run', 'smoke:start'))
+	const { runId: secondRunId } = JSON.parse(
+		runConvex(
+			'run',
+			'smoke:start',
+			JSON.stringify({ resourceRef: 'packed-component-2' }),
+		),
+	)
+	const firstPage = JSON.parse(
+		runConvex(
+			'run',
+			'smoke:list',
+			JSON.stringify({
+				state: 'pending',
+				paginationOpts: { cursor: null, numItems: 1 },
+			}),
+		),
+	)
+	if (firstPage.page.length !== 1 || firstPage.page[0]._id !== secondRunId) {
+		throw new Error(`Unexpected first approval page: ${JSON.stringify(firstPage)}`)
+	}
+	const secondPage = JSON.parse(
+		runConvex(
+			'run',
+			'smoke:list',
+			JSON.stringify({
+				state: 'pending',
+				paginationOpts: {
+					cursor: firstPage.continueCursor,
+					numItems: 10,
+				},
+			}),
+		),
+	)
+	if (
+		secondPage.page.length !== 1 ||
+		secondPage.page[0]._id !== runId ||
+		secondPage.page[0]._id === firstPage.page[0]._id
+	) {
+		throw new Error(
+			`Unexpected continuation approval page: ${JSON.stringify(secondPage)}`,
+		)
+	}
+
+	let decision
+	let lastError
+	for (let attempt = 0; attempt < 10; attempt += 1) {
+		try {
+			decision = JSON.parse(
+				runConvex('run', 'smoke:decide', JSON.stringify({ runId })),
+			)
+			break
+		} catch (error) {
+			lastError = error
+			const currentStatus = JSON.parse(
+				runConvex('run', 'smoke:status', JSON.stringify({ runId })),
+			)
+			if (currentStatus.state === 'approved') {
+				decision = currentStatus
+				break
+			}
+			await new Promise((resolve) => setTimeout(resolve, 500))
+		}
+	}
+	if (!decision) throw lastError
+	if (decision.state !== 'approved') {
+		throw new Error(`Unexpected decision response: ${JSON.stringify(decision)}`)
+	}
+	const history = JSON.parse(
+		runConvex('run', 'smoke:history', JSON.stringify({ runId })),
+	)
+	if (history.length !== 1 || history[0].decision !== 'approved') {
+		throw new Error(`Unexpected approval history: ${JSON.stringify(history)}`)
+	}
+	let status
+	for (let attempt = 0; attempt < 20; attempt += 1) {
+		status = JSON.parse(
+			runConvex('run', 'smoke:status', JSON.stringify({ runId })),
+		)
+		if (status.execution?.type === 'completed') break
+		await new Promise((resolve) => setTimeout(resolve, 500))
+	}
+	if (status?.execution?.type !== 'completed') {
+		throw new Error(`Approval callback did not complete: ${JSON.stringify(status)}`)
+	}
+	console.log(`packed component smoke passed with ${installer}`)
+} finally {
+	rmSync(temporaryRoot, { recursive: true, force: true })
+}

package/src/test.ts

@@ -6,8 +6,8 @@
  * registers the COMPILED component modules from dist, so dist is the only
  * code the package ships.
  */
-import approvalsSchema from '../dist/components/approvals/schema.mjs'
-import foundationSchema from '../dist/components/foundation/schema.mjs'
+import approvalsSchema from '../dist/components/approvals/schema.js'
+import foundationSchema from '../dist/components/foundation/schema.js'
 
 const foundationModules = import.meta.glob(
 	'../dist/components/foundation/**/*.mjs',

package/dist/components/approvals/schema.mjs

@@ -1,2 +0,0 @@
-import{approvalDecisionDocument as e,approvalRunDocument as t}from"./validators.mjs";import{zodToConvex as n}from"convex-helpers/server/zod4";import{defineSchema as r,defineTable as i}from"convex/server";var a=r({approvalRuns:i(n(t)).index(`by_resourceType_and_resourceRef`,[`resourceType`,`resourceRef`]).index(`by_scopeRef_and_state`,[`scopeRef`,`state`]).index(`by_state_and_expiresAt`,[`state`,`expiresAt`]),approvalDecisions:i(n(e)).index(`by_runId_and_stepKey_and_actor_actorRef`,[`runId`,`stepKey`,`actor.actorRef`]).index(`by_runId_and_stepKey_and_decidedAt`,[`runId`,`stepKey`,`decidedAt`]).index(`by_runId_and_decidedAt`,[`runId`,`decidedAt`])});export{a as default};
-//# sourceMappingURL=schema.mjs.map

package/dist/components/approvals/schema.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.mjs","names":[],"sources":["../../../src/components/approvals/schema.ts"],"sourcesContent":["import { zodToConvex } from 'convex-helpers/server/zod4'\nimport { defineSchema, defineTable } from 'convex/server'\n\nimport { approvalDecisionDocument, approvalRunDocument } from './validators'\n\nexport default defineSchema({\n\tapprovalRuns: defineTable(zodToConvex(approvalRunDocument))\n\t\t.index('by_resourceType_and_resourceRef', ['resourceType', 'resourceRef'])\n\t\t.index('by_scopeRef_and_state', ['scopeRef', 'state'])\n\t\t.index('by_state_and_expiresAt', ['state', 'expiresAt']),\n\tapprovalDecisions: defineTable(zodToConvex(approvalDecisionDocument))\n\t\t.index('by_runId_and_stepKey_and_actor_actorRef', [\n\t\t\t'runId',\n\t\t\t'stepKey',\n\t\t\t'actor.actorRef',\n\t\t])\n\t\t.index('by_runId_and_stepKey_and_decidedAt', [\n\t\t\t'runId',\n\t\t\t'stepKey',\n\t\t\t'decidedAt',\n\t\t])\n\t\t.index('by_runId_and_decidedAt', ['runId', 'decidedAt']),\n})\n"],"mappings":"4MAKA,IAAA,EAAe,EAAa,CAC3B,aAAc,EAAY,EAAY,CAAmB,CAAC,CAAC,CACzD,MAAM,kCAAmC,CAAC,eAAgB,aAAa,CAAC,CAAC,CACzE,MAAM,wBAAyB,CAAC,WAAY,OAAO,CAAC,CAAC,CACrD,MAAM,yBAA0B,CAAC,QAAS,WAAW,CAAC,EACxD,kBAAmB,EAAY,EAAY,CAAwB,CAAC,CAAC,CACnE,MAAM,0CAA2C,CACjD,QACA,UACA,gBACD,CAAC,CAAC,CACD,MAAM,qCAAsC,CAC5C,QACA,UACA,WACD,CAAC,CAAC,CACD,MAAM,yBAA0B,CAAC,QAAS,WAAW,CAAC,CACzD,CAAC"}

package/dist/components/foundation/schema.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.mjs","names":[],"sources":["../../../src/components/foundation/schema.ts"],"sourcesContent":["import { defineSchema } from 'convex/server'\n\n/** Foundation is a capability-free in-process kernel and owns no business data. */\nexport default defineSchema({})\n"],"mappings":"6CAGA,IAAA,EAAe,EAAa,CAAC,CAAC"}