@cargo-ai/cdk 0.1.1

package/README.md

@@ -0,0 +1,187 @@
+# Cargo CDK
+
+Define your entire Cargo workspace in code — connectors, models, plays, tools,
+agents, MCP servers, context, folders, files, workers and apps — and deploy it
+declaratively, the same way you'd manage cloud infrastructure with Pulumi or the
+AWS CDK. For a complete overview, see the [Cargo CDK docs](https://docs.getcargo.ai/cdk/overview).
+
+## Requirements
+
+- Node.js 22.x
+- A Cargo API token (create in your workspace under **Settings → API**)
+
+## Installation
+
+Install the CDK in your project (for the `define*` builders you import in your
+resource files):
+
+```bash
+npm install @cargo-ai/cdk
+```
+
+The `cargo-ai cdk` commands ship with the Cargo CLI — install it globally:
+
+```bash
+npm install -g @cargo-ai/cli
+cargo-ai login --token <your-api-token>
+```
+
+## Quick start
+
+Scaffold a starter project from a template:
+
+```bash
+cargo-ai cdk init my-workspace            # minimal 'blank' template (default)
+cargo-ai cdk init my-workspace --template full  # every resource type, wired up
+cargo-ai cdk init --list-templates        # see all templates
+cd my-workspace && npm install
+```
+
+Or add a resource file yourself — importing a file **is** registration, there's
+no manifest to maintain:
+
+```ts
+// my-workspace/contacts.ts
+import { defineConnector, defineModel, secret } from "@cargo-ai/cdk";
+
+// `secret()` reads the value at deploy time and keeps it out of state and the
+// content hash — use it for credentials. The config shape is per-integration
+// (HubSpot takes a Private App token or an OAuth refresh token); run
+// `cargo-ai cdk types` to have it type-checked (see Typed config below).
+export const hubspot = defineConnector("hubspot", {
+  integration: "hubspot",
+  config: { method: "privateApp", accessToken: secret("HUBSPOT_API_KEY") },
+});
+
+// Pass the connector handle as `dataset` — the model depends on it, so the CDK
+// creates the connector first and injects its dataset uuid.
+export const contacts = defineModel("contacts", {
+  dataset: hubspot,
+  extractSlug: "fetchRecords",
+});
+```
+
+```bash
+export HUBSPOT_API_KEY=...                # secret() reads this at deploy time
+cargo-ai cdk plan   --dir my-workspace    # offline diff — no API calls
+cargo-ai cdk deploy --dir my-workspace    # create everything, write cargo.state.json
+```
+
+Re-running `deploy` only changes what changed; an unchanged workspace is a no-op.
+
+## Typed config
+
+`defineConnector` and `defineModel` config are typed against your workspace's
+actual integration schemas. Generate the types once:
+
+```bash
+cargo-ai cdk types --dir my-workspace
+```
+
+They land in `.cargo-ai/`. Add it to your tsconfig `include` with an explicit
+glob — a bare `.cargo-ai` (a dot-dir) is ignored by TypeScript:
+
+```jsonc
+// tsconfig.json
+"include": ["*.ts", ".cargo-ai/**/*.d.ts"]
+```
+
+After that, `config` is checked against the integration's schema — e.g. HubSpot
+is a discriminated union, so the editor completes `method` and requires the
+matching credential, and `secret()` is accepted wherever a credential is
+expected. Re-run `cdk types` after adding or changing workspace integrations.
+
+Typing is a bonus, never a gate: an integration you haven't synced (or a custom
+one) falls back to a loose `Record<string, unknown>`, so `deploy` still works
+without ever running `cdk types`.
+
+## Defining resources
+
+Every Cargo resource has a `define*` builder that returns a **handle**. Wire
+resources together by passing one handle to another — the dependency graph is
+just your variable graph. Pass the **handle** directly (or `xxRef("uuid")` for a
+resource you didn't define in code); no `.uuid` at the call site. Where a
+reference takes per-call options, wrap it as `{ ref, …options }`.
+
+```ts
+import { defineAgent, defineTool, defineWorkflow } from "@cargo-ai/cdk";
+
+const flow = defineWorkflow("enrich", { input, output }, ({ input, ai }) => …);
+export const enrich = defineTool("enrich", { workflow: flow, emojiSlug: "mag" });
+
+export const sdr = defineAgent("sdr", {
+  connector: openai,                              // handle (or connectorRef("…"))
+  languageModel: "gpt-4o",
+  systemPrompt: "Qualify inbound leads.",
+  models: [{ ref: contacts, readOnly: true }],    // handle + options
+  tools: [enrich],                                // bare handle
+});
+```
+
+See [Defining Resources](https://docs.getcargo.ai/cdk/resources) for every
+builder (connectors, models, plays, tools, agents, MCP servers, context, folders,
+files, workers, apps) and the slug rules.
+
+### Context
+
+`defineContext` manages the workspace's context repository — its git-backed GTM
+knowledge base of markdown/MDX — as code. Point it at a local folder and/or pass
+inline files:
+
+```ts
+import { defineContext } from "@cargo-ai/cdk";
+
+export const context = defineContext({
+  dir: "./context", // sync a local folder of .md/.mdx
+  files: { "generated/icp.md": buildIcp() }, // + inline additions/overrides
+});
+```
+
+There is one context repo per workspace, so this is a singleton. On deploy it
+writes each changed file into the repo via the runtime — **additive**: files
+added elsewhere (the UI, other tooling) are left in place.
+
+## Commands
+
+```bash
+cargo-ai cdk init <directory>      # scaffold from a template (--template, --list-templates)
+cargo-ai cdk types                 # generate per-workspace types for typed config
+cargo-ai cdk plan                  # offline: diff the code against cargo.state.json
+cargo-ai cdk deploy                # create/update resources, write cargo.state.json
+cargo-ai cdk deploy --prune        # also delete resources removed from code
+cargo-ai cdk deploy --refresh      # re-read live resources, re-apply out-of-band changes
+cargo-ai cdk refresh               # read-only: report resources that drifted from code
+cargo-ai cdk import <id> <uuid>    # bind an existing live resource into state
+cargo-ai cdk rollback              # restore cargo.state.json from the pre-deploy snapshot
+cargo-ai cdk destroy --target <id> # tear down one resource
+cargo-ai cdk destroy --all         # tear down everything in state
+```
+
+Common flags: `--dir <path>`, `--yes` (skip the prompt — required in CI),
+`--json`, and `--force` (steal a stale state lock). See
+[Deploying](https://docs.getcargo.ai/cdk/deploying).
+
+## State & drift
+
+`cargo-ai cdk deploy` writes `cargo.state.json` — the link from your code to the
+resources Cargo created. **Commit it** (losing it orphans resources; recover a
+link with `cdk import`). It records only uuids, hashes and outputs — never
+secret values.
+
+Git-ignore the generated types and the working files the CDK writes alongside it
+(but commit `cargo.state.json`):
+
+```gitignore
+.cargo-ai/
+cargo.state.lock
+cargo.state.bak.json
+cargo.state.audit.jsonl
+```
+
+`cargo-ai cdk refresh` reports resources changed or deleted outside the CDK
+(e.g. edited in the Cargo UI); `cargo-ai cdk deploy --refresh` re-applies your
+code over them. See [State & Drift](https://docs.getcargo.ai/cdk/state-and-drift).
+
+## Documentation
+
+Full documentation: [docs.getcargo.ai/cdk](https://docs.getcargo.ai/cdk/overview).

package/build/src/core.d.ts

@@ -0,0 +1,83 @@
+export type Token = {
+    readonly __token: true;
+    readonly resourceId: string;
+    readonly field: string;
+};
+export declare function token(resourceId: string, field: string): Token;
+export declare function isToken(value: unknown): value is Token;
+export type ResourceKind = "connector" | "model" | "agent" | "play" | "tool" | "mcpServer" | "folder" | "file" | "worker" | "app" | "context";
+export type ResourceNode = {
+    readonly id: string;
+    readonly kind: ResourceKind;
+    readonly slug: string;
+    readonly spec: Record<string, unknown>;
+};
+/**
+ * Register a resource. Re-registering the SAME id with identical content is a
+ * no-op (the loader may evaluate a file more than once when it's imported both
+ * directly and transitively); re-registering an id with DIFFERENT content is a
+ * genuine duplicate slug and throws.
+ */
+export declare function register(node: ResourceNode): void;
+/**
+ * Deterministic JSON serialization for content hashing. Object keys are sorted
+ * recursively and `undefined`-valued keys are dropped, so the same logical spec
+ * always hashes the same regardless of how the author ordered keys or whether
+ * an optional field was passed as `undefined` vs omitted. Without this, the
+ * drift hash (and the register-dedup check) are sensitive to insertion order
+ * and produce spurious "update" diffs on every deploy. Arrays keep their order
+ * (it's semantically significant); Dates serialize to their ISO string.
+ */
+export declare function stableStringify(value: unknown): string;
+/** Every resource declared so far. */
+export declare function resources(): ResourceNode[];
+/** Clear the registry — the loader resets between runs; tests between cases. */
+export declare function resetRegistry(): void;
+/** Compose a resource's stable id from its kind + slug, validating the slug. */
+export declare function resourceId(kind: ResourceKind, slug: string): string;
+/** Collect the resource ids a spec depends on (every token reachable in it). */
+export declare function dependenciesOf(value: unknown, acc?: Set<string>): Set<string>;
+/** Deep-replace every token in a spec with the real value its producer returned. */
+export declare function resolveTokens(value: unknown, outputs: Map<string, Record<string, string>>): unknown;
+/**
+ * Read a config value from the environment at load time. Its value enters the
+ * spec — and therefore the content hash — so changing it shows as drift. Use for
+ * non-secret config you WANT to track; use `secret()` for rotating secrets.
+ * Returns a visible `${NAME}` placeholder when unset so it surfaces in a plan.
+ */
+export declare function env(name: string): string;
+/**
+ * A deferred reference to an environment secret, resolved at APPLY time and
+ * excluded from the content hash (the spec stores the reference, not the value).
+ * Rotating the secret therefore doesn't read as code drift — but a plain deploy
+ * won't push the new value either, since nothing in the hash changed; re-apply
+ * the resource (any other edit, or `--refresh`) to roll a rotated secret.
+ */
+export type SecretRef = {
+    readonly __secret: true;
+    readonly name: string;
+};
+export declare function secret(name: string): SecretRef;
+/**
+ * An encryption-typed connector/model config field. Server-side these fields are
+ * the `{ type: "encryption", isEncrypted, value }` envelope; in code you fill one
+ * with `secret("ENV")` (resolved to that envelope at deploy) — or, rarely, the
+ * raw envelope. `cargo-ai cdk types` prints `EncryptionRef` at exactly the schema
+ * positions typed as `encryption`, so `secret()` is accepted there and ONLY there.
+ */
+export type EncryptionRef = SecretRef | {
+    type: "encryption";
+    isEncrypted: boolean;
+    value: string;
+};
+export declare function isSecret(value: unknown): value is SecretRef;
+/**
+ * Deep-replace every `secret()` reference with its environment value, wrapped in
+ * Cargo's encryption envelope (`{ type: "encryption", isEncrypted: false, value }`).
+ * Every secret connector-config field (API keys, tokens, refresh tokens) is typed
+ * as this envelope server-side — the same shape the UI submits — so a bare string
+ * would be rejected as invalid config. The backend encrypts it at rest. Run at
+ * apply time (after token resolution). Throws if a referenced secret is unset.
+ */
+export declare function resolveSecrets(value: unknown): unknown;
+//# sourceMappingURL=core.d.ts.map

package/build/src/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/core.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,wBAAgB,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAE9D;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAMtD;AAGD,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,OAAO,GACP,OAAO,GACP,MAAM,GACN,MAAM,GACN,WAAW,GACX,QAAQ,GACR,MAAM,GACN,QAAQ,GACR,KAAK,GACL,SAAS,CAAC;AAEd,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,CAAC;AAoBF;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAUjD;AAMD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtD;AAgBD,sCAAsC;AACtC,wBAAgB,SAAS,IAAI,YAAY,EAAE,CAE1C;AAED,gFAAgF;AAChF,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAgCD,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMnE;AAGD,gFAAgF;AAChF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,GAAG,GAAE,GAAG,CAAC,MAAM,CAAa,GAC3B,GAAG,CAAC,MAAM,CAAC,CAcb;AAED,oFAAoF;AACpF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC3C,OAAO,CAoBT;AAGD;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGxC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAE9C;AAED;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,SAAS,GACT;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,WAAW,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAM3D;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAmBtD"}

package/build/src/core.js

@@ -0,0 +1,205 @@
+// @cargo-ai/cdk — core
+//
+// The runtime for Cargo's infrastructure-as-code graph (Pulumi/CDK-style).
+// `define*` builders REGISTER a resource and return a HANDLE whose outputs
+// (uuid, datasetUuid, …) are deferred TOKENS. You wire resources by passing one
+// resource's token into another's spec (`defineModel("c", { datasetUuid:
+// connector.datasetUuid })`) — the dependency graph is the variable graph. The
+// deploy engine topologically creates resources and resolves each token to the
+// real value its producer returned. No central manifest, no string slugs.
+import { createHash } from "node:crypto";
+export function token(resourceId, field) {
+    return { __token: true, resourceId, field };
+}
+export function isToken(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.__token === true);
+}
+// The registry is stored on globalThis under a global symbol, so that all copies
+// of this module — including the separate instance the tsx loader creates when it
+// transpiles a user's resource files — share ONE registry. Without this, define*
+// (running in the loader's module graph) would populate a different Map than the
+// host reads (the module-duplication / dual-package hazard).
+const REGISTRY_KEY = Symbol.for("@cargo-ai/cdk/registry");
+function registry() {
+    const holder = globalThis;
+    const existing = holder[REGISTRY_KEY];
+    if (existing !== undefined)
+        return existing;
+    const created = new Map();
+    holder[REGISTRY_KEY] = created;
+    return created;
+}
+/**
+ * Register a resource. Re-registering the SAME id with identical content is a
+ * no-op (the loader may evaluate a file more than once when it's imported both
+ * directly and transitively); re-registering an id with DIFFERENT content is a
+ * genuine duplicate slug and throws.
+ */
+export function register(node) {
+    const store = registry();
+    const existing = store.get(node.id);
+    if (existing !== undefined) {
+        if (specHash(existing.spec) === specHash(node.spec))
+            return;
+        throw new Error(`Duplicate resource "${node.id}" — slugs must be unique per kind.`);
+    }
+    store.set(node.id, node);
+}
+function specHash(spec) {
+    return createHash("sha256").update(stableStringify(spec)).digest("hex");
+}
+/**
+ * Deterministic JSON serialization for content hashing. Object keys are sorted
+ * recursively and `undefined`-valued keys are dropped, so the same logical spec
+ * always hashes the same regardless of how the author ordered keys or whether
+ * an optional field was passed as `undefined` vs omitted. Without this, the
+ * drift hash (and the register-dedup check) are sensitive to insertion order
+ * and produce spurious "update" diffs on every deploy. Arrays keep their order
+ * (it's semantically significant); Dates serialize to their ISO string.
+ */
+export function stableStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value instanceof Date)
+        return value.toISOString();
+    const source = value;
+    const out = {};
+    for (const key of Object.keys(source).sort()) {
+        const v = source[key];
+        if (v === undefined)
+            continue;
+        out[key] = canonicalize(v);
+    }
+    return out;
+}
+/** Every resource declared so far. */
+export function resources() {
+    return Array.from(registry().values());
+}
+/** Clear the registry — the loader resets between runs; tests between cases. */
+export function resetRegistry() {
+    globalThis[REGISTRY_KEY] = new Map();
+}
+// Slug rules, matched to what each Cargo create endpoint actually enforces so a
+// bad slug fails at define time (in `plan`) instead of mid-deploy. connector +
+// model are snake_case; worker + app use the hosting kebab format; the rest have
+// no API-side slug (uuid- or name-addressed), so they only get a sane base rule.
+const SNAKE_CASE = /^[a-z0-9]+(_[a-z0-9]+)*$/;
+const HOSTING_SLUG = /^[a-z][a-z0-9-]{2,30}$/;
+const BASE_SLUG = /^[a-z0-9][a-z0-9_-]*$/;
+function slugRule(kind) {
+    switch (kind) {
+        case "connector":
+        case "model":
+            return {
+                pattern: SNAKE_CASE,
+                help: 'snake_case — lowercase letters and digits joined by single underscores (e.g. "my_source")',
+            };
+        case "worker":
+        case "app":
+            return {
+                pattern: HOSTING_SLUG,
+                help: 'kebab-case — start with a letter, then 2-30 lowercase letters, digits or hyphens (e.g. "my-worker")',
+            };
+        default:
+            return {
+                pattern: BASE_SLUG,
+                help: 'lowercase letters, digits, hyphens and underscores, starting with a letter or digit (e.g. "my-thing")',
+            };
+    }
+}
+/** Compose a resource's stable id from its kind + slug, validating the slug. */
+export function resourceId(kind, slug) {
+    const { pattern, help } = slugRule(kind);
+    if (!pattern.test(slug)) {
+        throw new Error(`invalid ${kind} slug "${slug}" — must be ${help}.`);
+    }
+    return `${kind}:${slug}`;
+}
+// ── graph helpers used by the deploy engine ──────────────────────────────────
+/** Collect the resource ids a spec depends on (every token reachable in it). */
+export function dependenciesOf(value, acc = new Set()) {
+    if (isToken(value)) {
+        acc.add(value.resourceId);
+        return acc;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            dependenciesOf(item, acc);
+        return acc;
+    }
+    if (value !== null && typeof value === "object") {
+        for (const item of Object.values(value))
+            dependenciesOf(item, acc);
+        return acc;
+    }
+    return acc;
+}
+/** Deep-replace every token in a spec with the real value its producer returned. */
+export function resolveTokens(value, outputs) {
+    if (isToken(value)) {
+        const produced = outputs.get(value.resourceId);
+        const resolved = produced === undefined ? undefined : produced[value.field];
+        if (resolved === undefined) {
+            throw new Error(`Unresolved token ${value.resourceId}.${value.field} — producer not applied yet.`);
+        }
+        return resolved;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveTokens(item, outputs));
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolveTokens(v, outputs)]));
+    }
+    return value;
+}
+// ── secrets ──────────────────────────────────────────────────────────────────
+/**
+ * Read a config value from the environment at load time. Its value enters the
+ * spec — and therefore the content hash — so changing it shows as drift. Use for
+ * non-secret config you WANT to track; use `secret()` for rotating secrets.
+ * Returns a visible `${NAME}` placeholder when unset so it surfaces in a plan.
+ */
+export function env(name) {
+    const value = process.env[name];
+    return value === undefined ? `\${${name}}` : value;
+}
+export function secret(name) {
+    return { __secret: true, name };
+}
+export function isSecret(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.__secret === true);
+}
+/**
+ * Deep-replace every `secret()` reference with its environment value, wrapped in
+ * Cargo's encryption envelope (`{ type: "encryption", isEncrypted: false, value }`).
+ * Every secret connector-config field (API keys, tokens, refresh tokens) is typed
+ * as this envelope server-side — the same shape the UI submits — so a bare string
+ * would be rejected as invalid config. The backend encrypts it at rest. Run at
+ * apply time (after token resolution). Throws if a referenced secret is unset.
+ */
+export function resolveSecrets(value) {
+    if (isSecret(value)) {
+        const resolved = process.env[value.name];
+        if (resolved === undefined) {
+            throw new Error(`secret "${value.name}" is not set — export ${value.name} before deploying.`);
+        }
+        return { type: "encryption", isEncrypted: false, value: resolved };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveSecrets(item));
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolveSecrets(v)]));
+    }
+    return value;
+}

package/build/src/deploy/apply.d.ts

@@ -0,0 +1,55 @@
+import { type CompileInput, type PlanEntry, type State, type StateEntry } from "./compile.js";
+import type { LiveReaders } from "./refresh.js";
+export type Outputs = Record<string, string>;
+export type Executors = {
+    connector(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+        datasetUuid: string;
+    }>;
+    model(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+    agent(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+    play(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+    tool(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+    mcpServer(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+    folder(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+    file(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+    worker(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+        url: string;
+    }>;
+    app(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+        url: string;
+    }>;
+    context(spec: Record<string, unknown>, prior: StateEntry | undefined): Promise<Outputs & {
+        uuid: string;
+    }>;
+};
+export type ApplyResult = {
+    state: State;
+    applied: PlanEntry[];
+    skipped: PlanEntry[];
+};
+export type ApplyProgress = {
+    phase: "start" | "done";
+    id: string;
+    change: "create" | "update";
+    index: number;
+    total: number;
+};
+export declare function apply(input: CompileInput, executors: Executors, persist?: (state: State) => void, readers?: LiveReaders, onProgress?: (event: ApplyProgress) => void): Promise<ApplyResult>;
+//# sourceMappingURL=apply.d.ts.map

package/build/src/deploy/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/deploy/apply.ts"],"names":[],"mappings":"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"}