@intentius/chant 0.124.12 → 0.124.14

package/dist/components/component.schema.json

@@ -0,0 +1,271 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://intentius.io/chant/schemas/component/v1/component.schema.json",
+  "title": "Component",
+  "description": "The portable JSON contract for a chant component — a releasable unit (service, infra, or producer/library) declared as data. This document is the substrate: chant's TypeScript authoring form projects to it, and a non-chant or legacy component may hand-write it directly. See docs/src/content/docs/components/component-contract.mdx and composition-and-wiring.mdx, which are authoritative over this schema.",
+  "type": "object",
+  "required": ["name", "dependsOn", "deploy"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Optional self-reference to this schema's $id, for editor tooling and validators."
+    },
+    "contractVersion": {
+      "type": "string",
+      "const": "1.0.0",
+      "description": "Version of the Component contract this document conforms to. Versioned independently of chant's own release train."
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
+      "description": "Kebab-case component identifier, unique within the project. Used as the node name in the dependency graph and as the `@<component>` prefix in cross-component wiring references."
+    },
+    "dependsOn": {
+      "type": "array",
+      "description": "Other component names that must complete before this one runs. Ordering only — no logic. Resolved by `chant graph --stacks` into order and parallel-safe waves.",
+      "items": { "type": "string", "minLength": 1 },
+      "default": []
+    },
+    "build": { "$ref": "#/$defs/BuildSpec" },
+    "deploy": {
+      "type": "array",
+      "description": "The component's own composition over shared capabilities: an ordered list of phases. verify and rollback fall out of the capabilities used (e.g. a Verify phase, or a capability's own compensation) rather than being separate top-level fields.",
+      "items": { "$ref": "#/$defs/Phase" },
+      "minItems": 1
+    },
+    "verify": {
+      "type": "array",
+      "description": "Optional standalone verify phases, for components that separate verification from the main deploy composition (e.g. re-run as a health check outside a deploy). Most components instead include a Verify phase inline in `deploy`.",
+      "items": { "$ref": "#/$defs/Phase" }
+    },
+    "rollback": {
+      "type": "array",
+      "description": "Optional explicit compensation phases, executed in reverse order on terminal failure of `deploy` (a saga). Equivalent in shape to an Op's `onFailure`. Most rollback instead falls out of per-step `rollback`/compensation declared by the capabilities used; this field is for a component-level override or an escape-hatch capability with no native compensation.",
+      "items": { "$ref": "#/$defs/Phase" }
+    },
+    "archetype": {
+      "$ref": "#/$defs/Archetype",
+      "description": "Optional explicit archetype hint. When omitted, the archetype is inferred structurally from which phases/capability families are present (see the archetype table in component-contract.mdx)."
+    },
+    "liveNames": {
+      "type": "array",
+      "description": "Optional: the live lexicon entity/resource name(s) this component owns, when they differ from `name` (#598). `chant components status --live` reconciles the release ledger against live evidence by joining on this name; omitted entirely (the default), the join falls back to `name` itself with no behavior change. A component that owns several live entities (e.g. a fan-out cluster with one stack per node) may list them all.",
+      "items": { "type": "string", "minLength": 1 },
+      "minItems": 1
+    },
+    "composites": {
+      "type": "array",
+      "description": "Optional: the composite kind name(s) this component's deployed resources come from, when a consumer cannot infer it from `name` (#1492). Without this, a consumer joining a composite graph to the component DAG guesses by kebab-casing each composite's kind and matching it against this component's `name`, which only holds when a component maps 1:1 to a composite named for it. Omitted entirely (the default), the naming convention stays in effect with no behavior change. A component built from several composites may list them all.",
+      "items": { "type": "string", "minLength": 1 },
+      "minItems": 1
+    },
+    "environments": {
+      "type": "array",
+      "description": "Optional: where a release of this component goes, by environment (#3153). Each names an environment --env takes and, for it, the runtime that hosts the release, the URL it answers on, a custom domain attached to it, and the git remote its lifecycle records are pushed to. chant workspace graph --composites lists them first among the component's environments, with source component. Omitted, the component's environments are its member's.",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["name"],
+        "additionalProperties": false,
+        "properties": {
+          "name": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,62}$", "description": "The environment's name, as --env takes it." },
+          "runtime": { "type": "string", "minLength": 1, "description": "The runtime that hosts a release here, such as local or fly." },
+          "url": { "type": "string", "pattern": "^https?://", "description": "Where the released component answers." },
+          "domain": { "type": "string", "minLength": 1, "description": "A custom domain the release attaches to it." },
+          "lifecycle": { "type": "string", "minLength": 1, "description": "The git remote this environment's approvals, effect receipts and ledger records are pushed to." }
+        }
+      }
+    }
+  },
+  "$defs": {
+    "Archetype": {
+      "type": "string",
+      "enum": ["service", "infra", "producer-library"],
+      "description": "The three first-class shapes `deploy` can take. service: build -> publish -> apply -> verify (e.g. an ECS service behind an ALB). infra: apply -> verify, no build (e.g. a DynamoDB table, an EMR cluster). producer-library: build -> publish only, no service apply — emits an artifact other components consume (e.g. a JAR published to S3 for EMR)."
+    },
+
+    "BuildSpec": {
+      "type": "object",
+      "description": "Optional: source -> BuildArchive. Omitted entirely for config-only / infra components that apply existing templates with no build step.",
+      "required": ["kind"],
+      "properties": {
+        "kind": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Build capability verb, keyed by artifact type, e.g. \"docker-build\", \"zip-package\", \"jvm-build\". Not a closed enum — the capability registry is a plugin registry."
+        },
+        "context": {
+          "type": "string",
+          "description": "Build context path (e.g. a Docker build context directory)."
+        },
+        "into": {
+          "type": "string",
+          "const": "archive",
+          "description": "Build output always lands in the self-contained BuildArchive; this field documents that destination explicitly in the JSON projection."
+        }
+      },
+      "additionalProperties": true
+    },
+
+    "Phase": {
+      "type": "object",
+      "description": "One named phase of a deploy composition, run in order relative to sibling phases. Steps within a phase run sequentially unless `parallel` is set.",
+      "required": ["phase", "steps"],
+      "additionalProperties": false,
+      "properties": {
+        "phase": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Phase display name (e.g. \"Publish\", \"Apply\", \"Verify\", \"Seed\", \"Node 1\"). Also the namespace prior-step wiring references key off (`@Phase.field`)."
+        },
+        "steps": {
+          "type": "array",
+          "description": "Ordered steps in this phase. A step may itself be a Step (a capability invocation), a Gate, or a nested Phase — a fan-out unit is itself a mini-composition (see composition-and-wiring.mdx).",
+          "items": {
+            "anyOf": [
+              { "$ref": "#/$defs/Step" },
+              { "$ref": "#/$defs/Gate" },
+              { "$ref": "#/$defs/Phase" }
+            ]
+          },
+          "minItems": 1
+        },
+        "parallel": {
+          "type": "boolean",
+          "default": false,
+          "description": "Run all steps in this phase concurrently instead of sequentially."
+        },
+        "onFailure": {
+          "type": "array",
+          "description": "Compensation phases for this phase, executed in reverse order on failure (saga rollback). Capabilities that declare their own compensation get this for free; this field is for an explicit override.",
+          "items": { "$ref": "#/$defs/Phase" }
+        }
+      }
+    },
+
+    "Step": {
+      "type": "object",
+      "description": "A single capability invocation — the leaf unit of a composition. `kind` selects the capability (a verb, e.g. \"cfn-deploy\", \"publish-image\", \"ecs-update-service\"); the remaining properties are that capability's typed input. Capability-specific properties are open (the capability interface itself is out of scope for this schema — see #554); the handful of cross-cutting properties below are typed as WiringValue because they commonly carry a reference rather than a literal. `kind: \"gate\"` is reserved for the Gate step shape below, not a capability.",
+      "required": ["kind"],
+      "additionalProperties": true,
+      "properties": {
+        "kind": {
+          "type": "string",
+          "minLength": 1,
+          "not": { "const": "gate" },
+          "description": "Capability verb this step dispatches to, e.g. \"docker-build\", \"publish-image\", \"cfn-deploy\", \"ecs-update-service\", \"emr-start-job-run\", \"code-deploy\", \"wait-steady-state\", \"health-gate\", \"shell\". Not a closed enum — the capability registry is a plugin registry; new verbs are added without changing this schema."
+        },
+        "imageRef": {
+          "$ref": "#/$defs/WiringValue",
+          "description": "Reference to a published image digest, typically a prior-step reference like \"@Publish.digest\"."
+        },
+        "jar": {
+          "$ref": "#/$defs/WiringValue",
+          "description": "Reference to a published JAR/artifact location, typically a cross-component artifact reference like \"@jar-lib.publish.uri\"."
+        },
+        "revision": {
+          "$ref": "#/$defs/WiringValue",
+          "description": "Reference to a published revision/bundle location for host/code-delivery capabilities (e.g. code-deploy)."
+        },
+        "inputs": {
+          "type": "object",
+          "description": "Named inputs passed into an apply step, each of which may be a literal or any WiringValue reference — most commonly a stackOutput reference imported from another component's stack.",
+          "additionalProperties": { "$ref": "#/$defs/WiringValue" }
+        }
+      }
+    },
+
+    "GateName": {
+      "type": "string",
+      "minLength": 1,
+      "description": "A gate's name, on either of the two keys that may carry it."
+    },
+
+    "Gate": {
+      "type": "object",
+      "description": "Ends the run pending human approval. The driver decides a gate against the gate ledger when it reaches one; a gate nobody has approved stops the run there, and `chant approve <component> <gate>` records the resolution the next run reads.",
+      "required": ["kind"],
+      "oneOf": [
+        { "required": ["gate"], "properties": { "gate": { "$ref": "#/$defs/GateName" } } },
+        { "required": ["signalName"], "properties": { "signalName": { "$ref": "#/$defs/GateName" } } }
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "kind": { "type": "string", "const": "gate" },
+        "gate": {
+          "$ref": "#/$defs/GateName",
+          "description": "The gate's name — what `chant approve <component> <gate>` resolves."
+        },
+        "signalName": {
+          "$ref": "#/$defs/GateName",
+          "description": "Deprecated spelling of `gate` (chant #2202), accepted through 0.59.0 and removed in 0.60.0. Exactly one of `gate` and `signalName` may be present."
+        },
+        "timeout": {
+          "type": "string",
+          "description": "Duration string bounding the wait, e.g. \"48h\". Default: \"48h\"."
+        },
+        "description": {
+          "type": "string",
+          "description": "Human-readable description of the action required to unblock this gate."
+        }
+      }
+    },
+
+    "WiringValue": {
+      "description": "A string value that is either a literal or one of the three reference forms components use to wire to configuration, prior steps, cross-stack outputs, or cross-component artifacts. All forms are resolved by the graph (`chant graph --stacks`), never by orchestrator code.",
+      "oneOf": [
+        { "type": "string", "not": { "pattern": "^(\\$env\\.|@)" } },
+        { "$ref": "#/$defs/EnvReference" },
+        { "$ref": "#/$defs/PriorStepReference" },
+        { "$ref": "#/$defs/ComponentArtifactReference" },
+        { "$ref": "#/$defs/StackOutputReference" }
+      ]
+    },
+
+    "EnvReference": {
+      "type": "string",
+      "pattern": "^\\$env\\.[A-Za-z0-9_]+(\\.[A-Za-z0-9_]+)*$",
+      "description": "Reference to the current deploy environment's config, e.g. \"$env.registry\", \"$env.cluster\"."
+    },
+
+    "PriorStepReference": {
+      "type": "string",
+      "pattern": "^@[A-Za-z0-9_ ]+\\.[A-Za-z0-9_]+(\\.[A-Za-z0-9_]+)*$",
+      "description": "Reference to a prior step's output within the same component, addressed by phase name, e.g. \"@Publish.digest\", \"@Submit.runId\". Does not contain a dot before the phase name, distinguishing it from a cross-component reference (\"@<component>.publish...\")."
+    },
+
+    "ComponentArtifactReference": {
+      "type": "string",
+      "pattern": "^@[a-z0-9]+(-[a-z0-9]+)*\\.publish\\.(uri|digest|key)$",
+      "description": "Reference to another component's published artifact output, e.g. \"@jar-lib.publish.uri\", \"@search-service.publish.digest\". The referenced component must appear in this component's dependsOn; the graph resolves the reference into this step, never the orchestrator."
+    },
+
+    "StackOutputReference": {
+      "type": "object",
+      "description": "Reference to a cross-stack (CloudFormation/ARM/...) output exported by another stack, resolved by the graph the same way `stackOutput()` is resolved in the TypeScript authoring form. Replaces a `describe-stacks | jq` pipeline step.",
+      "required": ["stackOutput"],
+      "additionalProperties": false,
+      "properties": {
+        "stackOutput": {
+          "type": "object",
+          "required": ["stack", "name"],
+          "additionalProperties": false,
+          "properties": {
+            "stack": {
+              "type": "string",
+              "minLength": 1,
+              "description": "Name of the exporting component/stack, e.g. \"shared-alb\"."
+            },
+            "name": {
+              "type": "string",
+              "minLength": 1,
+              "description": "Name of the exported output, e.g. \"ListenerArn\", \"ClusterArn\"."
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/dist/components/config-defaults.js

@@ -0,0 +1,130 @@
+/**
+ * Config-defaults pass (#629, epic #551 follow-up to #606/#622/#626) — the
+ * missing link between `chant.config.ts`'s `sbom`/`signing`/`vulnPolicy`
+ * sections and the steps that actually consume them.
+ *
+ * Before this module, `resolveSigningDefaults`/`resolveVulnPolicy`
+ * (../config.ts) were never called anywhere in the `chant run --components`
+ * path, and `resolveSbomFormat` was only ever called in post-hoc display
+ * code. A component author had to hand-code `format`/`keyless`/`oidcIssuer`/
+ * `policy` into every `generate-sbom`/`sign`/`attest-provenance`/`verify`/
+ * `vuln-gate` step, even when the project already declared a project-wide
+ * default in `chant.config.ts` — the config sections were decorative.
+ *
+ * `applyConfigDefaults` walks a `DriverComponent`'s `deploy` composition
+ * (including nested fan-out phases and `onFailure` compensation phases) and
+ * returns a new component with each recognized step's config-driven fields
+ * filled in *only where the step didn't already set them* — per-step value
+ * wins over config wins over the capability's own built-in default, the
+ * precedence every one of the `resolve*` docstrings in ../config.ts already
+ * claims. This module is the caller that finally makes that claim true.
+ *
+ * Kept entirely outside `./driver.ts`: the driver stays capability-agnostic
+ * (it dispatches by `kind` and knows nothing about `sbom`/`signing`/
+ * `vulnPolicy`) — this pass transforms the component's plain-data composition
+ * *before* it ever reaches the driver, the same "resolve config, then hand a
+ * capability-agnostic caller a fully-formed input" convention `resolveSbomFormat`'s
+ * own docstring already describes for its callers.
+ */
+import { resolveSbomFormat, resolveSigningDefaults, resolveVulnPolicy } from "../config.js";
+function isGateStep(step) {
+    return step.kind === "gate";
+}
+function isPhaseStep(step) {
+    return typeof step.phase === "string" && Array.isArray(step.steps);
+}
+/**
+ * Fill one step's config-resolved defaults in place (into a shallow clone),
+ * per its `kind` — the only place this module branches on capability kind,
+ * matching how `../verbs/sbom.ts`'s `generate` is the only branch point for
+ * artifact type. Fields the step already set are never overwritten.
+ */
+function applyStepDefaults(step, config) {
+    switch (step.kind) {
+        case "generate-sbom": {
+            const format = step.format;
+            return { ...step, format: resolveSbomFormat(config, format) };
+        }
+        case "sign":
+        case "attest-provenance": {
+            const defaults = resolveSigningDefaults(config);
+            const next = { ...step };
+            // Only fill `keyless`/`key` when the step didn't already declare its own
+            // signing method — an explicit `key` (or `keyless`) on the step always
+            // wins over the project default, mirroring `resolveSigningDefaults`'s
+            // own "caller supplies any per-call override" contract.
+            if (next.keyless === undefined && next.key === undefined) {
+                if (!defaults.keyless && defaults.key) {
+                    next.key = defaults.key;
+                }
+                else if (defaults.identityPolicyDefaults.expectedIssuer !== undefined) {
+                    // Keyless flow: thread the configured OIDC issuer through as a
+                    // `keyless` override so `cosign sign/attest --oidc-issuer` picks it
+                    // up, without clobbering any keyless sub-fields the step itself set.
+                    const existingKeyless = next.keyless ?? {};
+                    next.keyless = { oidcIssuer: defaults.identityPolicyDefaults.expectedIssuer, ...existingKeyless };
+                }
+            }
+            return next;
+        }
+        case "verify": {
+            const defaults = resolveSigningDefaults(config).identityPolicyDefaults;
+            const existingPolicy = step.policy ?? {};
+            const policy = { ...existingPolicy };
+            if (policy.expectedIssuer === undefined && defaults.expectedIssuer !== undefined) {
+                policy.expectedIssuer = defaults.expectedIssuer;
+            }
+            if (policy.expectedIdentity === undefined && defaults.expectedIdentity !== undefined) {
+                policy.expectedIdentity = defaults.expectedIdentity;
+            }
+            if (policy.identityIsRegexp === undefined && defaults.identityIsRegexp !== undefined) {
+                policy.identityIsRegexp = defaults.identityIsRegexp;
+            }
+            if (policy.key === undefined && defaults.key !== undefined) {
+                policy.key = defaults.key;
+            }
+            return { ...step, policy };
+        }
+        case "vuln-gate": {
+            const configPolicy = resolveVulnPolicy(config);
+            const existingPolicy = step.policy ?? {};
+            // Config policy fills the gaps; the step's own `policy` wins field-by-field.
+            const policy = { ...configPolicy, ...existingPolicy };
+            return { ...step, policy };
+        }
+        default:
+            return step;
+    }
+}
+/** Recursively apply step defaults across one entry (a step, a gate, or a nested fan-out phase). Gates are returned unchanged — they carry no capability input to resolve. */
+function applyEntryDefaults(entry, config) {
+    if (isGateStep(entry))
+        return entry;
+    if (isPhaseStep(entry))
+        return applyPhaseDefaults(entry, config);
+    return applyStepDefaults(entry, config);
+}
+/** Apply step defaults across one phase's `steps` (recursing into nested fan-out phases) and its `onFailure` compensation phases. */
+function applyPhaseDefaults(phase, config) {
+    return {
+        ...phase,
+        steps: phase.steps.map((entry) => applyEntryDefaults(entry, config)),
+        ...(phase.onFailure ? { onFailure: phase.onFailure.map((p) => applyPhaseDefaults(p, config)) } : {}),
+    };
+}
+/**
+ * Return `component` with `chant.config.ts`'s `sbom`/`signing`/`vulnPolicy`
+ * defaults filled into its `deploy` (and `rollback`, which shares the same
+ * `DriverPhase[]` shape and can equally carry a `verify`/`vuln-gate` step)
+ * composition, wherever a step didn't already specify the value itself.
+ * Non-destructive: returns a new component/phase/step tree, never mutates
+ * `component` in place, so a caller holding the original discovered
+ * `DriverComponent` (e.g. for `chant describe`) is unaffected.
+ */
+export function applyConfigDefaults(component, config) {
+    return {
+        ...component,
+        deploy: component.deploy.map((phase) => applyPhaseDefaults(phase, config)),
+        ...(component.rollback ? { rollback: component.rollback.map((phase) => applyPhaseDefaults(phase, config)) } : {}),
+    };
+}

package/dist/components/deploy-units.js

@@ -0,0 +1,60 @@
+/**
+ * The deploy-family kinds that name a unit. cfn-deploy's unit is its stack;
+ * kubectl-apply's is the ownership stack its labels carry (#1495 piece 2);
+ * helm-upgrade's is its release (#1495 piece 4). Listing a kind here is safe
+ * before its lexicon implements `describeStackStatus` — units whose lexicon
+ * has no observer are skipped by the caller, the same absent-observer path as
+ * before.
+ */
+export const DEPLOY_UNIT_RULES = [
+    { kind: "cfn-deploy", field: "stack", lexicon: "aws" },
+    { kind: "kubectl-apply", field: "stack", lexicon: "k8s" },
+    // kustomize renders, then applies through the same stack-labelled pipeline —
+    // so its unit is observed by the identical label sweep (#1548).
+    { kind: "kustomize-apply", field: "stack", lexicon: "k8s" },
+    // GitOps verbs apply the controller's CR through that same pipeline — the
+    // unit is the CR itself under its stack label, observed by the identical
+    // label sweep (#1549 piece 2).
+    { kind: "argo-app", field: "stack", lexicon: "k8s" },
+    { kind: "flux-reconcile", field: "stack", lexicon: "k8s" },
+    { kind: "helm-upgrade", field: "release", lexicon: "helm" },
+    // A Terraform-family root (#3049). Its unit is the root's name in
+    // `terraform.roots`, which is also the member a gated wave's digest names.
+    { kind: "terraform-apply", field: "root", lexicon: "terraform" },
+];
+/**
+ * Every distinct deploy unit a component's phases target, in declaration
+ * order. A step may itself be a nested `Phase`, so the walk recurses; a
+ * resolved component carries the unit as a concrete string. Pure.
+ */
+export function deployUnits(deploy) {
+    const byKind = new Map(DEPLOY_UNIT_RULES.map((r) => [r.kind, r]));
+    const seen = new Set();
+    const units = [];
+    const walkSteps = (steps) => {
+        for (const step of steps) {
+            // A step may itself be a nested Phase (it carries its own `steps`). Step
+            // is open-typed (capability inputs), so discriminate structurally.
+            const nested = step.steps;
+            if (Array.isArray(nested)) {
+                walkSteps(nested);
+                continue;
+            }
+            const s = step;
+            const rule = s.kind ? byKind.get(s.kind) : undefined;
+            if (!rule)
+                continue;
+            const unit = s[rule.field];
+            if (typeof unit !== "string" || unit.length === 0)
+                continue;
+            const key = `${rule.lexicon}\0${unit}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            units.push({ unit, lexicon: rule.lexicon });
+        }
+    };
+    for (const phase of deploy)
+        walkSteps(phase.steps);
+    return units;
+}

package/dist/components/discover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/components/discover.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAIH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAO1D,2EAA2E;AAC3E,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,SAAS,CAAC;IACrB,0HAA0H;IAC1H,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,wBAAwB;IACvC,0GAA0G;IAC1G,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC7C,oDAAoD;IACpD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED,8CAA8C;AAC9C,MAAM,WAAW,yBAAyB;IACxC;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACtC;AAED,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,uBAAuB,EAAE,GAAG;IAC9E,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC7C,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAkCA;AA6BD;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,wBAAwB,CAAC,CAsCnC"}
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/components/discover.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAIH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAQ1D,2EAA2E;AAC3E,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,SAAS,CAAC;IACrB,0HAA0H;IAC1H,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,wBAAwB;IACvC,0GAA0G;IAC1G,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC7C,oDAAoD;IACpD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED,8CAA8C;AAC9C,MAAM,WAAW,yBAAyB;IACxC;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACtC;AAED,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,uBAAuB,EAAE,GAAG;IAC9E,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC7C,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAkCA;AA8BD;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,wBAAwB,CAAC,CAsCnC"}