@alneas/eaos-server 0.0.0-stage → 0.2.0

package/dist/artifacts-CteHmCMI.d.ts

@@ -0,0 +1,614 @@
+import { PluginManifest } from '@alneas/eaos-core/plugin-sdk';
+import { LifecyclePlugin } from './lifecycle-engine/index.js';
+
+/**
+ * Supported deployment capability categories used to validate component declarations.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+declare const deploymentComponentKinds: readonly ["frontend", "api", "mcp", "service", "function", "worker", "job", "webhook", "workflow", "database", "infrastructure", "storage", "cache", "queue", "search", "integration", "native", "model", "data-import"];
+/**
+ * Supported declarative work phases; inspection never executes these actions.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+declare const deploymentActions: readonly ["build", "test", "preview", "provision", "configure", "migrate", "deploy", "verify", "import", "enable"];
+/**
+ * One declared deployable capability with explicit placement and nonsecret host requirements.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+interface DeploymentComponent {
+    /**
+     * Unique component ID within the plugin.
+     */
+    id: string;
+    /**
+     * False marks an optional capability; omitted means required.
+     *
+     * Optional provider/native capabilities remain visible without requiring every deployment to adopt them.
+     */
+    required?: boolean;
+    /**
+     * Supported frontend/server/storage/compute capability category.
+     */
+    kind: typeof deploymentComponentKinds[number];
+    /**
+     * Declared host/container/function/database/cloud/native/external placement.
+     */
+    placement: 'host' | 'container' | 'function' | 'database' | 'cloud' | 'native' | 'external';
+    /**
+     * Optional runtime descriptor.
+     */
+    runtime?: string;
+    /**
+     * Exact checksummed inventory asset references.
+     *
+     * References to files in the checksummed inventory, not arbitrary source paths.
+     */
+    assets?: string[];
+    /**
+     * Author-side asset selectors resolved by packing; unresolved patterns prevent completion.
+     *
+     * Author-side selectors resolved to exact assets by the packer; emitted inventories omit these.
+     */
+    assetPatterns?: string[];
+    /**
+     * Optional entry asset path.
+     */
+    entry?: string;
+    /**
+     * Canonical schema contract IDs and semver ranges, never copied DDL.
+     *
+     * Canonical contract IDs/ranges; no copied DDL.
+     */
+    dataContracts?: Record<string, string>;
+    /**
+     * Optional required tool ranges and host binding/adapter names.
+     */
+    requirements?: {
+        /**
+         * Tool-name to required-version/range map declared by the plugin.
+         */
+        tools?: Record<string, string>;
+        /**
+         * Required nonsecret host binding names; never credential values.
+         */
+        bindings?: string[];
+        /**
+         * Required host adapter capability names.
+         */
+        adapters?: string[];
+    };
+}
+/**
+ * Declarative host-approved work and dependency ordering for deployment evidence.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+interface DeploymentTask {
+    /**
+     * Unique task ID within the plugin.
+     */
+    id: string;
+    /**
+     * Existing components whose work this task covers.
+     */
+    componentIds: string[];
+    /**
+     * Supported build/test/provision/deploy/etc. phase.
+     */
+    action: typeof deploymentActions[number];
+    /**
+     * Artifact work is reusable; environment and tenant work require corresponding target evidence.
+     */
+    scope: 'artifact' | 'environment' | 'tenant';
+    /**
+     * Whether successful task evidence is required for completion.
+     */
+    required: boolean;
+    /**
+     * Existing task IDs that must succeed before this task is considered unblocked.
+     */
+    dependsOn: string[];
+    /**
+     * Host-approved executor reference; inspection never launches it.
+     *
+     * Host-approved executor reference. Inspection never executes it or argv.
+     */
+    executor: string;
+    /**
+     * Optional declarative arguments; never automatically executed by inspection.
+     */
+    argv?: string[];
+    /**
+     * Optional human operator instructions.
+     */
+    instructions?: string;
+}
+/**
+ * Classified deployment component/task graph for one lifecycle feature.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+interface DeploymentPlugin {
+    /**
+     * Plugin ID covered by the inventory lifecycle bundle.
+     */
+    id: string;
+    /**
+     * Unique deployable capability definitions.
+     */
+    components: DeploymentComponent[];
+    /**
+     * Unique work definitions forming an acyclic dependency graph.
+     */
+    tasks: DeploymentTask[];
+}
+/**
+ * Nonsecret exact environment, physical placement and optional tenant context for scoped evidence.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+interface DeploymentTarget {
+    /**
+     * Nonblank deployment environment label.
+     */
+    environment: string;
+    /**
+     * Optional exact lifecycle backend ID; required for database work evidence.
+     */
+    backendId?: string;
+    /**
+     * Optional physical database identity; required with backendId for database evidence.
+     */
+    databaseId?: string;
+    /**
+     * Optional concrete tenant; required for tenant tasks and absent for environment tasks.
+     */
+    tenantId?: string;
+}
+/**
+ * Reported execution evidence bound to a task, inventory and optional destination revision.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+interface DeploymentResult {
+    /**
+     * Declared inventory plugin ID.
+     */
+    pluginId: string;
+    /**
+     * Declared plugin task ID.
+     */
+    taskId: string;
+    /**
+     * Exact environment/tenant target; absent for artifact work.
+     */
+    target?: DeploymentTarget;
+    /**
+     * Reported running/succeeded/failed result; no independent execution proof is implied.
+     */
+    status: 'running' | 'succeeded' | 'failed';
+    /**
+     * Exact UTC ISO timestamp including millisecond precision; increases per task/target/placement.
+     */
+    recordedAt: string;
+    /**
+     * Nonblank host/operator identity reporting the result.
+     */
+    actor: string;
+    /**
+     * Nonempty distinct nonsecret evidence references, such as reviewed logs or CI receipts.
+     *
+     * Non-secret evidence references, such as a reviewed log, CI run or lifecycle plan receipt.
+     */
+    evidence: string[];
+    /**
+     * Optional explicit destination identity paired with placementSha256; forbidden for artifact results.
+     *
+     * Environment/tenant evidence bound to a reviewed component placement. Artifact results remain reusable.
+     */
+    destinationId?: string;
+    /**
+     * Hash of reviewed placement/binding revisions paired with destinationId.
+     */
+    placementSha256?: string;
+}
+/**
+ * Operator/host-owned reported evidence journal pinned to one inventory digest.
+ *
+ *
+ * Host/operator-owned journal. This is reported evidence, never runtime admission authority.
+ * @see summarizeDeployment for canonical integration usage.
+ */
+interface DeploymentReceipt {
+    /**
+     * Receipt discriminator; currently 1.
+     */
+    apiVersion: 1;
+    /**
+     * Exact inventory owner to which these results belong.
+     */
+    owner: string;
+    /**
+     * Lowercase 64-character SHA-256 of the trusted inventory bytes.
+     */
+    inventorySha256: string;
+    /**
+     * Reported task outcomes in increasing per-task/target/placement timestamp order.
+     */
+    results: DeploymentResult[];
+}
+/**
+ * Derived task readiness: pending, dependency-blocked, stale evidence, running, succeeded or failed.
+ *
+ * @see summarizeDeployment for canonical integration usage.
+ */
+type DeploymentTaskStatus = 'pending' | 'blocked' | 'stale' | 'running' | 'succeeded' | 'failed';
+/**
+ * Validates declared plugin component references and task dependencies before artifact inspection.
+ *
+ * Validate references and the dependency DAG before artifact registration or status inspection.
+ * @param inventory - Deployment inventory with checksummed asset metadata and optional per-plugin work declarations.
+ * @returns The original plugin array, or undefined for legacy inventories without plugin declarations.
+ * @throws Error for invalid/duplicate declarations, unsupported component/action/scope, unknown references, cycles or missing required work.
+ *
+ * @remarks
+ * Requires explicit lifecycle-bundle coverage, known assets/components, acyclic dependencies and work for adopted components. This validates declarations without executing tasks or proving artifact file checksums.
+ *
+ * @example
+ * ```typescript
+ * import { validateDeploymentPlugins, type DeploymentInventory } from '@alneas/eaos-server/platform';
+ * export function inspectDeclaration(inventory: DeploymentInventory) { return validateDeploymentPlugins(inventory); }
+ * ```
+ */
+declare function validateDeploymentPlugins(inventory: DeploymentInventory): DeploymentPlugin[] | undefined;
+/**
+ * Validates the exact nonsecret environment/backend/database/tenant target shape.
+ * @param value - Untrusted target object with a nonblank environment and optional nonblank identity references.
+ * @returns Completes without a value and narrows the input to DeploymentTarget.
+ * @throws Error for missing/blank identity fields or unknown target properties.
+ *
+ * @remarks
+ * Does not resolve backend existence, tenant membership or deployment authority.
+ *
+ * @example
+ * ```typescript
+ * import { validateDeploymentTarget } from '@alneas/eaos-server/platform/deployment';
+ * const target: unknown = { environment: 'review' };
+ * validateDeploymentTarget(target);
+ * ```
+ */
+declare function validateDeploymentTarget(value: unknown): asserts value is DeploymentTarget;
+/**
+ * Validates version-1 reported task evidence and strictly increasing timestamps per task/target/placement.
+ * @param value - Untrusted receipt with owner, pinned inventory SHA-256 and task result records.
+ * @returns Completes without a value and narrows the input to DeploymentReceipt.
+ * @throws Error for malformed/extra fields, invalid hashes/timestamps, missing evidence or nonincreasing repeated-result timestamps.
+ *
+ * @remarks
+ * Each result needs a UTC millisecond ISO timestamp, actor and nonempty distinct evidence references. destinationId and placementSha256 must occur together. This validates shape/order only; it does not independently verify evidence or grant runtime admission.
+ *
+ * @example
+ * ```typescript
+ * import { validateDeploymentReceipt } from '@alneas/eaos-server/platform/deployment';
+ * const receipt: unknown = { apiVersion: 1, owner: 'reports', inventorySha256: 'a'.repeat(64), results: [] };
+ * validateDeploymentReceipt(receipt);
+ * ```
+ */
+declare function validateDeploymentReceipt(value: unknown): asserts value is DeploymentReceipt;
+/**
+ * Aggregates host/operator task evidence into dependency-aware plugin and component completion states.
+ *
+ * Aggregate operator/host evidence only. A build receipt cannot complete DB/infra/deployment tasks.
+ * @param inventory - Validated artifact declaration; missing plugins remains legacy-unclassified.
+ * @param inventorySha256 - Trusted lowercase 64-character inventory digest.
+ * @param receipts - Reported receipts; defaults to none.
+ * @param target - Optional current environment/backend/database/tenant context for scoped work.
+ * @returns A read-only summary with coverage, artifact resolution, task states and ignored owner/stale-inventory/placement receipts.
+ * @throws Error for invalid declarations/receipts/hash/target, undeclared tasks, scope mismatch or conflicting equal-time evidence.
+ *
+ * @remarks
+ * No task executes. Artifact work is reusable; environment/tenant evidence must match scope and database work needs explicit backend/database identities. Newer dependency evidence makes older success stale. Completion is host-reported evidence, never admission authority.
+ *
+ * @example
+ * ```typescript
+ * import { summarizeDeployment, type DeploymentInventory, type DeploymentReceipt, type DeploymentTarget } from '@alneas/eaos-server/platform';
+ * export function inspect(inventory: DeploymentInventory, digest: string, receipts: DeploymentReceipt[], target?: DeploymentTarget) { return summarizeDeployment(inventory, digest, receipts, target); }
+ * ```
+ */
+declare function summarizeDeployment(inventory: DeploymentInventory, inventorySha256: string, receipts?: DeploymentReceipt[], target?: DeploymentTarget): {
+    owner: string;
+    inventorySha256: string;
+    target: DeploymentTarget | undefined;
+    coverage: "declared" | "legacy-unclassified";
+    artifactResolved: boolean;
+    complete: boolean;
+    plugins: {
+        id: string;
+        artifactResolved: boolean;
+        complete: boolean;
+        components: {
+            complete: boolean;
+            /**
+             * Unique component ID within the plugin.
+             */
+            id: string;
+            /**
+             * False marks an optional capability; omitted means required.
+             *
+             * Optional provider/native capabilities remain visible without requiring every deployment to adopt them.
+             */
+            required?: boolean;
+            /**
+             * Supported frontend/server/storage/compute capability category.
+             */
+            kind: (typeof deploymentComponentKinds)[number];
+            /**
+             * Declared host/container/function/database/cloud/native/external placement.
+             */
+            placement: "host" | "container" | "function" | "database" | "cloud" | "native" | "external";
+            /**
+             * Optional runtime descriptor.
+             */
+            runtime?: string;
+            /**
+             * Exact checksummed inventory asset references.
+             *
+             * References to files in the checksummed inventory, not arbitrary source paths.
+             */
+            assets?: string[];
+            /**
+             * Author-side asset selectors resolved by packing; unresolved patterns prevent completion.
+             *
+             * Author-side selectors resolved to exact assets by the packer; emitted inventories omit these.
+             */
+            assetPatterns?: string[];
+            /**
+             * Optional entry asset path.
+             */
+            entry?: string;
+            /**
+             * Canonical schema contract IDs and semver ranges, never copied DDL.
+             *
+             * Canonical contract IDs/ranges; no copied DDL.
+             */
+            dataContracts?: Record<string, string>;
+            /**
+             * Optional required tool ranges and host binding/adapter names.
+             */
+            requirements?: {
+                /**
+                 * Tool-name to required-version/range map declared by the plugin.
+                 */
+                tools?: Record<string, string>;
+                /**
+                 * Required nonsecret host binding names; never credential values.
+                 */
+                bindings?: string[];
+                /**
+                 * Required host adapter capability names.
+                 */
+                adapters?: string[];
+            };
+        }[];
+        tasks: {
+            status: DeploymentTaskStatus;
+            result?: DeploymentResult;
+            /**
+             * Unique task ID within the plugin.
+             */
+            id: string;
+            /**
+             * Existing components whose work this task covers.
+             */
+            componentIds: string[];
+            /**
+             * Supported build/test/provision/deploy/etc. phase.
+             */
+            action: (typeof deploymentActions)[number];
+            /**
+             * Artifact work is reusable; environment and tenant work require corresponding target evidence.
+             */
+            scope: "artifact" | "environment" | "tenant";
+            /**
+             * Whether successful task evidence is required for completion.
+             */
+            required: boolean;
+            /**
+             * Existing task IDs that must succeed before this task is considered unblocked.
+             */
+            dependsOn: string[];
+            /**
+             * Host-approved executor reference; inspection never launches it.
+             *
+             * Host-approved executor reference. Inspection never executes it or argv.
+             */
+            executor: string;
+            /**
+             * Optional declarative arguments; never automatically executed by inspection.
+             */
+            argv?: string[];
+            /**
+             * Optional human operator instructions.
+             */
+            instructions?: string;
+        }[];
+    }[];
+    ignoredReceipts: {
+        owner: string;
+        reason: string;
+    }[];
+    evidencePolicy: string;
+};
+
+/**
+ * Trusted code contributions restricted to explicit tenant IDs; registration never activates a plugin.
+ *
+ *
+ * Trusted package contributions; code registration does not grant tenant activation.
+ * @see PluginLifecycle for canonical integration usage.
+ */
+interface PlatformContribution {
+    /**
+     * Contribution contract discriminator; currently 1.
+     */
+    apiVersion: 1;
+    /**
+     * Contribution/package identity.
+     */
+    id: string;
+    /**
+     * Concrete admitted tenant catalog; never wildcard authorization.
+     */
+    tenantIds: string[];
+    /**
+     * Optional public plugin manifests contributed by the trusted package.
+     */
+    manifests?: PluginManifest[];
+    /**
+     * Optional trusted lifecycle release definitions.
+     */
+    lifecycle?: LifecyclePlugin[];
+    /**
+     * Optional plugin ID to allowed route-prefix contributions.
+     */
+    routePrefixes?: Record<string, string[]>;
+}
+/**
+ * Checksummed artifact metadata and explicit per-plugin deployment work, separate from runtime admission.
+ *
+ * @see PluginLifecycle for canonical integration usage.
+ */
+interface DeploymentInventory {
+    /**
+     * Inventory discriminator; currently 1.
+     */
+    apiVersion: 1;
+    /**
+     * Stable package/contribution owner used to bind receipts.
+     */
+    owner: string;
+    /**
+     * Optional package release version.
+     */
+    version?: string;
+    /**
+     * Optional declared execution runtime descriptor.
+     */
+    runtime?: string;
+    /**
+     * Optional ordered lifecycle plugin IDs; required for classified plugin work.
+     */
+    lifecycleBundle?: string[];
+    /**
+     * Tenant-scoped function source declarations and required tenant bindings.
+     */
+    functions: Array<{
+        /**
+         * Unique tenant-scoped function identity.
+         */
+        id: string;
+        /**
+         * Project-relative packaged function/database source path.
+         */
+        source: string;
+        /**
+         * Function scope discriminator; must be tenant.
+         */
+        scope: 'tenant';
+        /**
+         * Explicit binding names that the host must resolve separately for each tenant.
+         */
+        requiredTenantBindings: string[];
+    }>;
+    /**
+     * Optional adopted existing-history database declaration; never an instruction to recreate history.
+     */
+    database?: {
+        /**
+         * Project-relative packaged function/database source path.
+         */
+        source: string;
+        /**
+         * Database history policy; adopt-existing-history never recreates historical migrations.
+         */
+        mode: 'adopt-existing-history';
+        /**
+         * Canonical tenant isolation column; currently tenant_id.
+         */
+        tenantColumn: 'tenant_id';
+    };
+    /**
+     * Exact project-relative packaged asset paths and SHA-256 digests.
+     */
+    assets: Array<{
+        /**
+         * Exact project-relative packaged asset path.
+         */
+        path: string;
+        /**
+         * Lowercase SHA-256 digest of the asset bytes.
+         */
+        sha256: string;
+    }>;
+    /**
+     * Optional classified component/task declarations; absence is legacy-unclassified.
+     *
+     * Explicit per-plugin composition and required work. Omission is legacy/unclassified.
+     */
+    plugins?: DeploymentPlugin[];
+}
+/**
+ * Trusted project-relative artifact/module registration with explicit tenant/plugin scopes.
+ *
+ *
+ * Paths are project-relative. Settings are non-secret; use host-resolved references for credentials.
+ * @see PluginLifecycle for canonical integration usage.
+ */
+interface PlatformPackage {
+    /**
+     * Unique nonblank registration ID.
+     */
+    id: string;
+    /**
+     * Project-relative inventory path without absolute/traversal/backslash segments.
+     */
+    inventory: string;
+    /**
+     * Project-relative entry module path without traversal.
+     */
+    module: string;
+    /**
+     * Nonempty concrete trimmed tenant IDs; wildcard is forbidden.
+     */
+    tenantIds: string[];
+    /**
+     * Nonempty unique plugin IDs contributed by this package.
+     */
+    pluginIds: string[];
+    /**
+     * Optional nonsecret host configuration object; resolve credentials by host references.
+     */
+    settings?: Record<string, unknown>;
+}
+/**
+ * Validates explicit checksummed package registrations and concrete tenant/plugin scope metadata.
+ * @param value - Untrusted package registration array, or undefined for no packages.
+ * @returns The original accepted array, or a new empty array for undefined.
+ * @throws Error for nonarray input, unknown fields, duplicate package IDs, invalid paths, empty/duplicate plugin IDs or invalid tenant scopes.
+ *
+ * @remarks
+ * Checks project-relative nontraversing inventory/module paths and nonsecret settings shape. It does not load files, verify checksums, resolve membership or activate plugins.
+ *
+ * @example
+ * ```typescript
+ * import { validatePlatformPackages } from '@alneas/eaos-server/platform/artifacts';
+ * const packages = validatePlatformPackages([{ id: 'reports', inventory: '.eaos/packages/reports/deployment.json', module: '.eaos/packages/reports/index.js', tenantIds: ['sample'], pluginIds: ['reports'] }]);
+ * ```
+ */
+declare function validatePlatformPackages(value: unknown): PlatformPackage[];
+
+export { deploymentComponentKinds as f, deploymentActions as g, validateDeploymentReceipt as k, validateDeploymentTarget as l, validatePlatformPackages as m, summarizeDeployment as s, validateDeploymentPlugins as v };
+export type { DeploymentComponent as D, PlatformPackage as P, DeploymentTaskStatus as a, DeploymentTarget as b, DeploymentResult as c, DeploymentInventory as d, DeploymentReceipt as e, DeploymentPlugin as h, DeploymentTask as i, PlatformContribution as j };

package/dist/auth-hooks/api-key.d.ts

@@ -0,0 +1,75 @@
+import { ApiKeyRecord, PlatformPrincipal } from '@alneas/eaos-core';
+
+/**
+ * Host persistence lookup for {@link resolveApiKey}; records must retain hashed credentials and lifecycle state.
+ */
+interface ApiKeyLookup {
+    /**
+     * Reads a key record by its 12-character public prefix.
+     * @param prefix - Prefix extracted from an eaos_ credential; never the full secret.
+     * @returns The stored record, or null if absent.
+     * @throws Persistence errors propagate to resolveApiKey callers.
+     
+     * @example
+     * ```typescript
+     * import type { ApiKeyLookup } from "@alneas/eaos-server/auth-hooks";
+     * export async function findStoredApiKey(lookup: ApiKeyLookup, parsedPrefix: string) {
+     *   const record = await lookup.findByPrefix(parsedPrefix);
+     *   return record; // A record match still requires secret, scope and lifecycle verification.
+     * }
+     * ```
+     */
+    findByPrefix(prefix: string): Promise<ApiKeyRecord | null>;
+}
+/**
+ * Verifies a stored API key and resolves its trusted user, tenant, and copied scopes.
+ * @param headers - Raw authorization and apiKey header values; a Bearer credential takes precedence, and credentials must begin with eaos_.
+ * @param lookup - Host record lookup by public prefix; see {@link ApiKeyLookup}.
+ * @param options - requiredScope is checked by core verification; now overrides the verification clock; authorize runs only after cryptographic and scope checks and must return exactly true.
+ * @returns A principal with apiKeyId and empty roles, or null for malformed, missing, invalid, expired, insufficiently scoped, or host-denied credentials.
+ * @throws Rejects on lookup or authorize failure; these are not converted to null.
+ * @remarks Membership and tenant lifecycle checks belong in authorize. No key usage or persistence update occurs here.
+ * @example
+ * ```typescript
+ * import { resolveApiKey, type ApiKeyLookup } from "@alneas/eaos-server/auth-hooks/api-key";
+ * import type { ApiKeyRecord } from "@alneas/eaos-core";
+ * export async function authenticate(
+ *   authorization: string | null,
+ *   lookup: ApiKeyLookup,
+ *   authorize: (record: ApiKeyRecord) => Promise<boolean>,
+ * ) {
+ *   return resolveApiKey({ authorization }, lookup, { requiredScope: "records:read", authorize });
+ * }
+ * ```
+ */
+declare function resolveApiKey(headers: {
+    /**
+   * Optional raw Authorization header; a parsed Bearer credential takes precedence over the dedicated apiKey value.
+   */
+    authorization?: string | null;
+    /**
+   * Optional dedicated API-key header used only when no Bearer credential is parsed; surrounding whitespace is trimmed.
+   */
+    apiKey?: string | null;
+}, lookup: ApiKeyLookup, options?: {
+    /**
+   * Optional exact key scope checked by core cryptographic/lifecycle verification.
+   */
+    requiredScope?: string;
+    /**
+   * Optional verification clock override; omission uses the core verifier clock.
+   */
+    now?: Date;
+    /**
+   * Optional live membership/lifecycle callback after key verification; receives the stored record and must return exactly true to allow, while errors reject resolution.
+   */
+    authorize?: (record: ApiKeyRecord) => Promise<boolean> | boolean;
+}): Promise<(PlatformPrincipal & {
+    /**
+   * Stored key record ID attached to the resolved principal for audit/correlation, never the credential secret.
+   */
+    apiKeyId: string;
+}) | null>;
+
+export { resolveApiKey };
+export type { ApiKeyLookup };

package/dist/auth-hooks/api-key.js

@@ -0,0 +1,7 @@
+import {
+  resolveApiKey
+} from "../chunk-ZC3XWU7B.js";
+export {
+  resolveApiKey
+};
+//# sourceMappingURL=api-key.js.map

package/dist/auth-hooks/api-key.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}