@pipeline-builder/pipeline-manager 3.4.71 → 3.4.72

package/README.md

@@ -42,11 +42,22 @@ pipeline-manager provision --target fargate \
 
 # Tear it down (AWS targets prompt you to TYPE the target id to confirm):
 pipeline-manager provision --target fargate --teardown --execute
+
+# Bootstrap a fresh machine — sparse-clones ONLY the deploy folders this target
+# + options need (here: deploy/bin + deploy/local), then deploys + registers:
+pipeline-manager provision --target local --repo --execute --yes \
+  --admin-email admin@acme.com --admin-password 's3cret'
+
+# Add post-install loads (each also adds its folder to the sparse clone):
+pipeline-manager provision --target local --repo --with-all --with-smoke-test --execute
 ```
 
 - **Advise → execute → teardown.** Default is read-only. `--execute` deploys — it refuses on failed prerequisites or missing inputs, then verifies health and offers to run `init-platform`. `--teardown` removes a deployment (`local`/`minikube` stop the stack; **EC2/Fargate delete their CloudFormation stacks irreversibly** and require typing the target id to confirm — `--force` skips it for CI).
 - **Self-healing.** On a failed deploy it matches known CloudFormation issues (cause + fix) and can auto-fix + retry a few — e.g. an existing SES identity → re-run with `--skip-ses-identity`. Gated and bounded by `--retries` (the scripts are idempotent, so a re-run resumes).
 - **AI-optional.** Set `ANTHROPIC_API_KEY` (or `AI_PROVIDER` + its key) to parse a natural-language `--prompt` and add free-form failure diagnosis; without a key it falls back to the deterministic advisor + issue matcher.
+- **Bootstrap a fresh machine (`--repo`).** Without a checkout, `--repo` git-clones the platform repo first, then runs from it. The clone is **sparse + partial** (`--filter=blob:none` + cone `sparse-checkout`, git ≥ 2.27 — else a full-clone fallback): it materializes only the deploy folders the selected target + options need. The common base is just `deploy/bin`; each target adds its own folder (e.g. `deploy/local`; minikube is self-contained), and each post-install load adds its folder. Re-syncs are **additive** — a single `--workdir` can accumulate multiple targets. Override with `--repo <url>`, `--ref <branch|tag>`, `--workdir <dir>`.
+- **Run in Docker, zero host installs.** Don't want `git`/`yq`/AWS CLI on your machine? [`deploy/bin/provision-docker.sh`](../../deploy/bin/provision-docker.sh) runs `provision` inside a throwaway `node:24-slim` container, installing only the tools the chosen target needs (ec2/fargate → git + AWS CLI, mounts `~/.aws`; local → git + yq + docker CLI via the shared daemon). Host footprint = just Docker. Args pass straight through: `deploy/bin/provision-docker.sh --target fargate --repo --domain … --execute --yes`.
+- **Post-install steps.** After deploy + health, `provision` registers the admin (non-interactive with `--admin-email`/`--admin-password`) and runs opt-in loads — `--with-plugins` (adds `deploy/plugins` + `deploy/codebuild`), `--with-compliance` (`deploy/compliance`), `--with-samples` (`deploy/samples`), or `--with-all`. Plus `--with-smoke-test` (read-only API check), `--with-events` (AWS EventBridge ingestion), and repeatable `--post-step "<cmd>"`. Default is register-only; `--no-init` skips even that. All steps are idempotent, so re-running with more options just layers them on.
 
 The underlying `bin/setup.sh` / `bin/teardown.sh` scripts remain the source of truth and can always be run directly. Full guide: [AWS deployment → AI-assisted install](https://mwashburn160.github.io/pipeline-builder/docs/aws-deployment#ai-assisted-install-provision).
 
@@ -56,7 +67,7 @@ The underlying `bin/setup.sh` / `bin/teardown.sh` scripts remain the source of t
 
 | Command | Purpose |
 | --- | --- |
-| `provision` | Install (or tear down) the **platform** on local/Minikube/EC2/Fargate: prereq checks + assembles the exact `bin/setup.sh` command; `--execute` runs it (gated, then verifies health + `init-platform`), `--teardown` removes it. On failure it diagnoses + auto-fixes/retries known issues. See [Install the platform](#install-the-platform-provision). |
+| `provision` | Install (or tear down) the **platform** on local/Minikube/EC2/Fargate: prereq checks + assembles the exact `bin/setup.sh` command; `--execute` runs it (gated, then verifies health + post-install steps). `--repo` bootstraps a fresh machine via a **sparse** clone of only the needed deploy folders; `--with-plugins`/`--with-compliance`/`--with-samples`/`--with-all`/`--with-smoke-test`/`--with-events`/`--post-step` add post-install steps; `--teardown` removes it. On failure it diagnoses + auto-fixes/retries known issues. See [Install the platform](#install-the-platform-provision). |
 
 ### Project lifecycle
 

package/dist/agent/bootstrap.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Bootstrap the platform repo (sparse, partial clone).
+ *
+ * `provision` normally runs from a checkout of this repo, because the deploy
+ * scripts live under `deploy/`. To provision a fresh machine in one command, the
+ * operator passes `--repo`: provision git-clones the platform repo first, then
+ * runs every subsequent step (deploy, init-platform, post-steps) from the clone.
+ *
+ * A full clone is wasteful — the repo carries `packages/`, `api/`, `platform/`,
+ * `frontend/`, … none of which the deploy stack needs. So the clone is a
+ * **partial** (`--filter=blob:none`) + **cone sparse-checkout** that materializes
+ * only the deploy folders the selected target + options actually use. Pure
+ * command assembly here — no git is run; the caller executes the command via the
+ * same gated `runScript()` as the deploy.
+ */
+/** Canonical upstream platform repo, used when `--repo` is given without a value. */
+export declare const DEFAULT_REPO = "https://github.com/mwashburn160/pipeline-builder.git";
+/** Default ref to check out when bootstrapping (a branch or tag — see below). */
+export declare const DEFAULT_REF = "main";
+/** Default directory to clone into / run from. */
+export declare const DEFAULT_WORKDIR = "pipeline-builder";
+export interface BootstrapSpec {
+    /** Git URL to clone. */
+    readonly repo: string;
+    /** Branch or tag to check out. (Arbitrary SHAs may not fetch under --depth 1.) */
+    readonly ref: string;
+    /** Directory to clone into / run from (relative to the launch cwd). */
+    readonly workdir: string;
+    /** Deploy folders to materialize (cone sparse-checkout paths). */
+    readonly paths: readonly string[];
+    /** When true, skip the partial/sparse flags and do a plain full clone (git < 2.27). */
+    readonly full?: boolean;
+}
+/** Fill partial bootstrap inputs with defaults; `paths` is supplied by the caller. */
+export declare function resolveBootstrap(opts: {
+    repo?: string;
+    ref?: string;
+    workdir?: string;
+    full?: boolean;
+}, paths: readonly string[]): BootstrapSpec;
+/**
+ * Assemble the idempotent bootstrap command. Re-runnable, and **additive** across
+ * runs: if `<workdir>` is already a checkout it `sparse-checkout add`s the current
+ * paths (so folders from previously-provisioned targets/options are retained) and
+ * re-syncs to `<ref>`; otherwise it partial-clones, sets the cone, and checks out.
+ *
+ * - `--filter=blob:none` lazily fetches blobs; `--no-checkout` + cone sparse-checkout
+ *   ⇒ only the listed deploy folders land on disk (git ≥ 2.27).
+ * - `spec.full` falls back to a plain full clone (older git).
+ * - All interpolated values are single-quoted, so a hostile repo/ref/workdir/path
+ *   cannot break out of the command.
+ */
+export declare function bootstrapCommand(spec: BootstrapSpec): string;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/agent/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/agent/bootstrap.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AAEH,qFAAqF;AACrF,eAAO,MAAM,YAAY,yDAAyD,CAAC;AACnF,iFAAiF;AACjF,eAAO,MAAM,WAAW,SAAS,CAAC;AAClC,kDAAkD;AAClD,eAAO,MAAM,eAAe,qBAAqB,CAAC;AAElD,MAAM,WAAW,aAAa;IAC5B,wBAAwB;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,uFAAuF;IACvF,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,EACvE,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,aAAa,CAUf;AAOD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CA0B5D"}

package/dist/agent/bootstrap.js

@@ -0,0 +1,76 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Bootstrap the platform repo (sparse, partial clone).
+ *
+ * `provision` normally runs from a checkout of this repo, because the deploy
+ * scripts live under `deploy/`. To provision a fresh machine in one command, the
+ * operator passes `--repo`: provision git-clones the platform repo first, then
+ * runs every subsequent step (deploy, init-platform, post-steps) from the clone.
+ *
+ * A full clone is wasteful — the repo carries `packages/`, `api/`, `platform/`,
+ * `frontend/`, … none of which the deploy stack needs. So the clone is a
+ * **partial** (`--filter=blob:none`) + **cone sparse-checkout** that materializes
+ * only the deploy folders the selected target + options actually use. Pure
+ * command assembly here — no git is run; the caller executes the command via the
+ * same gated `runScript()` as the deploy.
+ */
+/** Canonical upstream platform repo, used when `--repo` is given without a value. */
+export const DEFAULT_REPO = 'https://github.com/mwashburn160/pipeline-builder.git';
+/** Default ref to check out when bootstrapping (a branch or tag — see below). */
+export const DEFAULT_REF = 'main';
+/** Default directory to clone into / run from. */
+export const DEFAULT_WORKDIR = 'pipeline-builder';
+/** Fill partial bootstrap inputs with defaults; `paths` is supplied by the caller. */
+export function resolveBootstrap(opts, paths) {
+    const pick = (v, fallback) => typeof v === 'string' && v.trim() !== '' ? v.trim() : fallback;
+    return {
+        repo: pick(opts.repo, DEFAULT_REPO),
+        ref: pick(opts.ref, DEFAULT_REF),
+        workdir: pick(opts.workdir, DEFAULT_WORKDIR),
+        paths,
+        full: opts.full ?? false,
+    };
+}
+/** Single-quote a value for safe shell interpolation (handles embedded quotes). */
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * Assemble the idempotent bootstrap command. Re-runnable, and **additive** across
+ * runs: if `<workdir>` is already a checkout it `sparse-checkout add`s the current
+ * paths (so folders from previously-provisioned targets/options are retained) and
+ * re-syncs to `<ref>`; otherwise it partial-clones, sets the cone, and checks out.
+ *
+ * - `--filter=blob:none` lazily fetches blobs; `--no-checkout` + cone sparse-checkout
+ *   ⇒ only the listed deploy folders land on disk (git ≥ 2.27).
+ * - `spec.full` falls back to a plain full clone (older git).
+ * - All interpolated values are single-quoted, so a hostile repo/ref/workdir/path
+ *   cannot break out of the command.
+ */
+export function bootstrapCommand(spec) {
+    const repo = shellQuote(spec.repo);
+    const ref = shellQuote(spec.ref);
+    const originRef = shellQuote(`origin/${spec.ref}`);
+    const dir = shellQuote(spec.workdir);
+    const paths = spec.paths.map(shellQuote).join(' ');
+    if (spec.full) {
+        // Full-clone fallback (no partial/sparse) for git < 2.27.
+        return [
+            `if [ -d ${dir}/.git ]; then`,
+            `  git -C ${dir} fetch --all --tags --prune && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,
+            'else',
+            `  git clone ${repo} ${dir} && git -C ${dir} checkout ${ref};`,
+            'fi',
+        ].join('\n');
+    }
+    return [
+        `if [ -d ${dir}/.git ]; then`,
+        // Additive: keep folders from earlier targets/options already in the cone.
+        `  git -C ${dir} sparse-checkout add ${paths} && git -C ${dir} fetch --filter=blob:none --depth 1 origin ${ref} && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,
+        'else',
+        `  git clone --filter=blob:none --no-checkout --depth 1 ${repo} ${dir} && git -C ${dir} sparse-checkout set --cone ${paths} && git -C ${dir} checkout ${ref};`,
+        'fi',
+    ].join('\n');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/agent/bootstrap.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;GAcG;AAEH,qFAAqF;AACrF,MAAM,CAAC,MAAM,YAAY,GAAG,sDAAsD,CAAC;AACnF,iFAAiF;AACjF,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC;AAClC,kDAAkD;AAClD,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAelD,sFAAsF;AACtF,MAAM,UAAU,gBAAgB,CAC9B,IAAuE,EACvE,KAAwB;IAExB,MAAM,IAAI,GAAG,CAAC,CAAqB,EAAE,QAAgB,EAAU,EAAE,CAC/D,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;IACjE,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;QACnC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC;QAChC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,eAAe,CAAC;QAC5C,KAAK;QACL,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,KAAK;KACzB,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAmB;IAClD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,SAAS,GAAG,UAAU,CAAC,UAAU,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACnD,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEnD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,0DAA0D;QAC1D,OAAO;YACL,WAAW,GAAG,eAAe;YAC7B,YAAY,GAAG,yCAAyC,GAAG,aAAa,GAAG,gBAAgB,GAAG,iBAAiB,SAAS,0BAA0B,GAAG,iBAAiB,GAAG,MAAM;YAC/K,MAAM;YACN,eAAe,IAAI,IAAI,GAAG,cAAc,GAAG,aAAa,GAAG,GAAG;YAC9D,IAAI;SACL,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACf,CAAC;IAED,OAAO;QACL,WAAW,GAAG,eAAe;QAC7B,2EAA2E;QAC3E,YAAY,GAAG,wBAAwB,KAAK,cAAc,GAAG,8CAA8C,GAAG,cAAc,GAAG,aAAa,GAAG,gBAAgB,GAAG,iBAAiB,SAAS,0BAA0B,GAAG,iBAAiB,GAAG,MAAM;QACnP,MAAM;QACN,0DAA0D,IAAI,IAAI,GAAG,cAAc,GAAG,+BAA+B,KAAK,cAAc,GAAG,aAAa,GAAG,GAAG;QAC9J,IAAI;KACL,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Bootstrap the platform repo (sparse, partial clone).\n *\n * `provision` normally runs from a checkout of this repo, because the deploy\n * scripts live under `deploy/`. To provision a fresh machine in one command, the\n * operator passes `--repo`: provision git-clones the platform repo first, then\n * runs every subsequent step (deploy, init-platform, post-steps) from the clone.\n *\n * A full clone is wasteful — the repo carries `packages/`, `api/`, `platform/`,\n * `frontend/`, … none of which the deploy stack needs. So the clone is a\n * **partial** (`--filter=blob:none`) + **cone sparse-checkout** that materializes\n * only the deploy folders the selected target + options actually use. Pure\n * command assembly here — no git is run; the caller executes the command via the\n * same gated `runScript()` as the deploy.\n */\n\n/** Canonical upstream platform repo, used when `--repo` is given without a value. */\nexport const DEFAULT_REPO = 'https://github.com/mwashburn160/pipeline-builder.git';\n/** Default ref to check out when bootstrapping (a branch or tag — see below). */\nexport const DEFAULT_REF = 'main';\n/** Default directory to clone into / run from. */\nexport const DEFAULT_WORKDIR = 'pipeline-builder';\n\nexport interface BootstrapSpec {\n  /** Git URL to clone. */\n  readonly repo: string;\n  /** Branch or tag to check out. (Arbitrary SHAs may not fetch under --depth 1.) */\n  readonly ref: string;\n  /** Directory to clone into / run from (relative to the launch cwd). */\n  readonly workdir: string;\n  /** Deploy folders to materialize (cone sparse-checkout paths). */\n  readonly paths: readonly string[];\n  /** When true, skip the partial/sparse flags and do a plain full clone (git < 2.27). */\n  readonly full?: boolean;\n}\n\n/** Fill partial bootstrap inputs with defaults; `paths` is supplied by the caller. */\nexport function resolveBootstrap(\n  opts: { repo?: string; ref?: string; workdir?: string; full?: boolean },\n  paths: readonly string[],\n): BootstrapSpec {\n  const pick = (v: string | undefined, fallback: string): string =>\n    typeof v === 'string' && v.trim() !== '' ? v.trim() : fallback;\n  return {\n    repo: pick(opts.repo, DEFAULT_REPO),\n    ref: pick(opts.ref, DEFAULT_REF),\n    workdir: pick(opts.workdir, DEFAULT_WORKDIR),\n    paths,\n    full: opts.full ?? false,\n  };\n}\n\n/** Single-quote a value for safe shell interpolation (handles embedded quotes). */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, \"'\\\\''\")}'`;\n}\n\n/**\n * Assemble the idempotent bootstrap command. Re-runnable, and **additive** across\n * runs: if `<workdir>` is already a checkout it `sparse-checkout add`s the current\n * paths (so folders from previously-provisioned targets/options are retained) and\n * re-syncs to `<ref>`; otherwise it partial-clones, sets the cone, and checks out.\n *\n * - `--filter=blob:none` lazily fetches blobs; `--no-checkout` + cone sparse-checkout\n *   ⇒ only the listed deploy folders land on disk (git ≥ 2.27).\n * - `spec.full` falls back to a plain full clone (older git).\n * - All interpolated values are single-quoted, so a hostile repo/ref/workdir/path\n *   cannot break out of the command.\n */\nexport function bootstrapCommand(spec: BootstrapSpec): string {\n  const repo = shellQuote(spec.repo);\n  const ref = shellQuote(spec.ref);\n  const originRef = shellQuote(`origin/${spec.ref}`);\n  const dir = shellQuote(spec.workdir);\n  const paths = spec.paths.map(shellQuote).join(' ');\n\n  if (spec.full) {\n    // Full-clone fallback (no partial/sparse) for git < 2.27.\n    return [\n      `if [ -d ${dir}/.git ]; then`,\n      `  git -C ${dir} fetch --all --tags --prune && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,\n      'else',\n      `  git clone ${repo} ${dir} && git -C ${dir} checkout ${ref};`,\n      'fi',\n    ].join('\\n');\n  }\n\n  return [\n    `if [ -d ${dir}/.git ]; then`,\n    // Additive: keep folders from earlier targets/options already in the cone.\n    `  git -C ${dir} sparse-checkout add ${paths} && git -C ${dir} fetch --filter=blob:none --depth 1 origin ${ref} && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,\n    'else',\n    `  git clone --filter=blob:none --no-checkout --depth 1 ${repo} ${dir} && git -C ${dir} sparse-checkout set --cone ${paths} && git -C ${dir} checkout ${ref};`,\n    'fi',\n  ].join('\\n');\n}\n"]}

package/dist/agent/executor.d.ts

@@ -16,9 +16,12 @@ export interface RunResult {
 /**
  * Run a shell command from `cwd`, streaming to the terminal. With `capture`,
  * stdout/stderr are tee'd and the tail retained (for diagnosis); without it,
- * stdio is fully inherited so interactive prompts work (init-platform).
+ * stdio is fully inherited so interactive prompts work (init-platform). `env` is
+ * merged over `process.env` for the child (e.g. the register step's load flags
+ * and admin creds — kept out of the displayed command so secrets never print).
  */
 export declare function runScript(command: string, cwd: string, opts?: {
     capture?: boolean;
+    env?: Record<string, string>;
 }): Promise<RunResult>;
 //# sourceMappingURL=executor.d.ts.map

package/dist/agent/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/agent/executor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,OAAO,EAAE,SAAS,SAAS,EAAE,GAC5B,MAAM,GAAG,IAAI,CAKf;AAED,gGAAgG;AAChG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sFAAsF;IACtF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAmB5G"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/agent/executor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,OAAO,EAAE,SAAS,SAAS,EAAE,GAC5B,MAAM,GAAG,IAAI,CAKf;AAED,gGAAgG;AAChG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sFAAsF;IACtF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAO,GAC7D,OAAO,CAAC,SAAS,CAAC,CAoBpB"}

package/dist/agent/executor.js

@@ -29,17 +29,20 @@ export function entrypointExists(target, cwd) {
 /**
  * Run a shell command from `cwd`, streaming to the terminal. With `capture`,
  * stdout/stderr are tee'd and the tail retained (for diagnosis); without it,
- * stdio is fully inherited so interactive prompts work (init-platform).
+ * stdio is fully inherited so interactive prompts work (init-platform). `env` is
+ * merged over `process.env` for the child (e.g. the register step's load flags
+ * and admin creds — kept out of the displayed command so secrets never print).
  */
 export function runScript(command, cwd, opts = {}) {
+    const childEnv = opts.env ? { ...process.env, ...opts.env } : process.env;
     return new Promise((resolve) => {
         if (!opts.capture) {
-            const child = spawn('bash', ['-lc', command], { cwd, stdio: 'inherit' });
+            const child = spawn('bash', ['-lc', command], { cwd, stdio: 'inherit', env: childEnv });
             child.on('close', (code) => resolve({ code: code ?? 1, tail: '' }));
             child.on('error', () => resolve({ code: 1, tail: '' }));
             return;
         }
-        const child = spawn('bash', ['-lc', command], { cwd, stdio: ['inherit', 'pipe', 'pipe'] });
+        const child = spawn('bash', ['-lc', command], { cwd, stdio: ['inherit', 'pipe', 'pipe'], env: childEnv });
         let tail = '';
         const cap = (chunk) => {
             process.stdout.write(chunk);
@@ -51,4 +54,4 @@ export function runScript(command, cwd, opts = {}) {
         child.on('error', (err) => resolve({ code: 1, tail: `${tail}\n${String(err)}` }));
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agent/post-steps.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Post-install steps.
+ *
+ * After the platform is deployed + health-checked, provision runs an ordered set
+ * of post-install steps: **register** (the admin, via `init-platform.sh`, driven
+ * non-interactively by env — which also performs any opt-in plugin/compliance/
+ * sample loads), then an optional **smoke-test**, **events** (AWS), and any
+ * operator **--post-step** commands. Pure, deterministic assembly here — provision
+ * runs each via the same gated `runScript()` as the deploy.
+ */
+import { type TargetId } from './targets.js';
+export interface PostStep {
+    /** Stable id (`register` / `smoke-test` / `events`) or `custom-N`. */
+    readonly id: string;
+    /** Human label shown in the plan. */
+    readonly label: string;
+    /** The exact command to run. */
+    readonly command: string;
+    /** Non-secret env applied to the child for this step (e.g. LOAD_* for register). */
+    readonly env?: Readonly<Record<string, string>>;
+}
+/** A requested step that doesn't apply to the chosen target. */
+export interface SkippedStep {
+    readonly id: string;
+    readonly reason: string;
+}
+export interface ResolvedPostSteps {
+    readonly steps: PostStep[];
+    readonly skipped: SkippedStep[];
+}
+export interface PostStepOptions {
+    readonly target: TargetId;
+    /** Base URL of the deployed platform (from deriveHealthUrl), or null. */
+    readonly url: string | null;
+    /** AWS region (ec2/fargate), if provided. */
+    readonly region?: string;
+    /** Load-step ids enabled via `--with-*` (drive init-platform's LOAD_* envs + sparse paths). */
+    readonly enabledLoadIds: readonly string[];
+    /** `--build-bootstrap`: build the CodeBuild bootstrap image during register. */
+    readonly buildBootstrap: boolean;
+    /** False when `--no-init` — skips the register step entirely. */
+    readonly init: boolean;
+    readonly smokeTest: boolean;
+    readonly events: boolean;
+    /** Raw operator `--post-step` commands, in order. */
+    readonly steps: readonly string[];
+}
+/**
+ * Resolve the ordered post-install step list: register → smoke-test → events →
+ * custom. `register` carries the load + BUILD_BOOTSTRAP env so init-platform runs
+ * the enabled loads non-interactively. Requested-but-inapplicable steps land in
+ * `skipped` so the caller can warn rather than silently drop them.
+ */
+export declare function resolvePostSteps(opts: PostStepOptions): ResolvedPostSteps;
+//# sourceMappingURL=post-steps.d.ts.map

package/dist/agent/post-steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-steps.d.ts","sourceRoot":"","sources":["../../src/agent/post-steps.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAEH,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,WAAW,QAAQ;IACvB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,+FAA+F;IAC/F,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AASD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,iBAAiB,CA+CzE"}

package/dist/agent/post-steps.js

@@ -0,0 +1,73 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Post-install steps.
+ *
+ * After the platform is deployed + health-checked, provision runs an ordered set
+ * of post-install steps: **register** (the admin, via `init-platform.sh`, driven
+ * non-interactively by env — which also performs any opt-in plugin/compliance/
+ * sample loads), then an optional **smoke-test**, **events** (AWS), and any
+ * operator **--post-step** commands. Pure, deterministic assembly here — provision
+ * runs each via the same gated `runScript()` as the deploy.
+ */
+import { LOAD_STEPS } from './targets.js';
+/** Compute the non-interactive env that drives init-platform's prompts. */
+function registerEnv(enabledLoadIds, buildBootstrap) {
+    const env = { BUILD_BOOTSTRAP: buildBootstrap ? 'y' : 'n' };
+    for (const step of LOAD_STEPS)
+        env[step.env] = enabledLoadIds.includes(step.id) ? 'y' : 'n';
+    return env;
+}
+/**
+ * Resolve the ordered post-install step list: register → smoke-test → events →
+ * custom. `register` carries the load + BUILD_BOOTSTRAP env so init-platform runs
+ * the enabled loads non-interactively. Requested-but-inapplicable steps land in
+ * `skipped` so the caller can warn rather than silently drop them.
+ */
+export function resolvePostSteps(opts) {
+    const steps = [];
+    const skipped = [];
+    if (opts.init) {
+        const enabled = LOAD_STEPS.filter((s) => opts.enabledLoadIds.includes(s.id)).map((s) => s.id);
+        const loads = enabled.length > 0 ? ` (+ ${enabled.join(', ')})` : '';
+        steps.push({
+            id: 'register',
+            label: `Register admin${loads}`,
+            command: `./deploy/bin/init-platform.sh ${opts.target}`,
+            env: registerEnv(opts.enabledLoadIds, opts.buildBootstrap),
+        });
+    }
+    if (opts.smokeTest) {
+        if (opts.url) {
+            // -k: local/minikube front a self-signed cert; harmless against real-cert AWS URLs.
+            steps.push({
+                id: 'smoke-test',
+                label: 'Smoke test — read-only API check',
+                command: `curl -fsSk ${opts.url}/api/version && echo 'smoke-test: API reachable'`,
+            });
+        }
+        else {
+            skipped.push({ id: 'smoke-test', reason: 'no platform URL to probe for this target' });
+        }
+    }
+    if (opts.events) {
+        if (opts.target === 'ec2' || opts.target === 'fargate') {
+            // Requires the pipeline-manager CLI on PATH; reads PLATFORM_BASE_URL /
+            // PLATFORM_SECRET_NAME from the environment (the command validates them).
+            steps.push({
+                id: 'events',
+                label: 'EventBridge ingestion (setup-events)',
+                command: `pipeline-manager setup-events${opts.region ? ` --region ${opts.region}` : ''}`,
+            });
+        }
+        else {
+            skipped.push({ id: 'events', reason: `not applicable to target '${opts.target}' (ec2/fargate only)` });
+        }
+    }
+    opts.steps.forEach((command, i) => {
+        if (command.trim() !== '')
+            steps.push({ id: `custom-${i + 1}`, label: `Custom step ${i + 1}`, command });
+    });
+    return { steps, skipped };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"post-steps.js","sourceRoot":"","sources":["../../src/agent/post-steps.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Post-install steps.\n *\n * After the platform is deployed + health-checked, provision runs an ordered set\n * of post-install steps: **register** (the admin, via `init-platform.sh`, driven\n * non-interactively by env — which also performs any opt-in plugin/compliance/\n * sample loads), then an optional **smoke-test**, **events** (AWS), and any\n * operator **--post-step** commands. Pure, deterministic assembly here — provision\n * runs each via the same gated `runScript()` as the deploy.\n */\n\nimport { LOAD_STEPS, type TargetId } from './targets.js';\n\nexport interface PostStep {\n  /** Stable id (`register` / `smoke-test` / `events`) or `custom-N`. */\n  readonly id: string;\n  /** Human label shown in the plan. */\n  readonly label: string;\n  /** The exact command to run. */\n  readonly command: string;\n  /** Non-secret env applied to the child for this step (e.g. LOAD_* for register). */\n  readonly env?: Readonly<Record<string, string>>;\n}\n\n/** A requested step that doesn't apply to the chosen target. */\nexport interface SkippedStep {\n  readonly id: string;\n  readonly reason: string;\n}\n\nexport interface ResolvedPostSteps {\n  readonly steps: PostStep[];\n  readonly skipped: SkippedStep[];\n}\n\nexport interface PostStepOptions {\n  readonly target: TargetId;\n  /** Base URL of the deployed platform (from deriveHealthUrl), or null. */\n  readonly url: string | null;\n  /** AWS region (ec2/fargate), if provided. */\n  readonly region?: string;\n  /** Load-step ids enabled via `--with-*` (drive init-platform's LOAD_* envs + sparse paths). */\n  readonly enabledLoadIds: readonly string[];\n  /** `--build-bootstrap`: build the CodeBuild bootstrap image during register. */\n  readonly buildBootstrap: boolean;\n  /** False when `--no-init` — skips the register step entirely. */\n  readonly init: boolean;\n  readonly smokeTest: boolean;\n  readonly events: boolean;\n  /** Raw operator `--post-step` commands, in order. */\n  readonly steps: readonly string[];\n}\n\n/** Compute the non-interactive env that drives init-platform's prompts. */\nfunction registerEnv(enabledLoadIds: readonly string[], buildBootstrap: boolean): Record<string, string> {\n  const env: Record<string, string> = { BUILD_BOOTSTRAP: buildBootstrap ? 'y' : 'n' };\n  for (const step of LOAD_STEPS) env[step.env] = enabledLoadIds.includes(step.id) ? 'y' : 'n';\n  return env;\n}\n\n/**\n * Resolve the ordered post-install step list: register → smoke-test → events →\n * custom. `register` carries the load + BUILD_BOOTSTRAP env so init-platform runs\n * the enabled loads non-interactively. Requested-but-inapplicable steps land in\n * `skipped` so the caller can warn rather than silently drop them.\n */\nexport function resolvePostSteps(opts: PostStepOptions): ResolvedPostSteps {\n  const steps: PostStep[] = [];\n  const skipped: SkippedStep[] = [];\n\n  if (opts.init) {\n    const enabled = LOAD_STEPS.filter((s) => opts.enabledLoadIds.includes(s.id)).map((s) => s.id);\n    const loads = enabled.length > 0 ? ` (+ ${enabled.join(', ')})` : '';\n    steps.push({\n      id: 'register',\n      label: `Register admin${loads}`,\n      command: `./deploy/bin/init-platform.sh ${opts.target}`,\n      env: registerEnv(opts.enabledLoadIds, opts.buildBootstrap),\n    });\n  }\n\n  if (opts.smokeTest) {\n    if (opts.url) {\n      // -k: local/minikube front a self-signed cert; harmless against real-cert AWS URLs.\n      steps.push({\n        id: 'smoke-test',\n        label: 'Smoke test — read-only API check',\n        command: `curl -fsSk ${opts.url}/api/version && echo 'smoke-test: API reachable'`,\n      });\n    } else {\n      skipped.push({ id: 'smoke-test', reason: 'no platform URL to probe for this target' });\n    }\n  }\n\n  if (opts.events) {\n    if (opts.target === 'ec2' || opts.target === 'fargate') {\n      // Requires the pipeline-manager CLI on PATH; reads PLATFORM_BASE_URL /\n      // PLATFORM_SECRET_NAME from the environment (the command validates them).\n      steps.push({\n        id: 'events',\n        label: 'EventBridge ingestion (setup-events)',\n        command: `pipeline-manager setup-events${opts.region ? ` --region ${opts.region}` : ''}`,\n      });\n    } else {\n      skipped.push({ id: 'events', reason: `not applicable to target '${opts.target}' (ec2/fargate only)` });\n    }\n  }\n\n  opts.steps.forEach((command, i) => {\n    if (command.trim() !== '') steps.push({ id: `custom-${i + 1}`, label: `Custom step ${i + 1}`, command });\n  });\n\n  return { steps, skipped };\n}\n"]}

package/dist/agent/prereqs.d.ts

@@ -6,11 +6,20 @@ export interface PrereqCheck {
     /** A failing required check blocks deployment; advisory ones are warnings. */
     readonly required: boolean;
 }
+/** True when git is on PATH (required to bootstrap a clone at all). */
+export declare function gitAvailable(): boolean;
+/**
+ * Cone `sparse-checkout` (+ `--filter=blob:none`) needs git ≥ 2.27. Below that,
+ * the bootstrap falls back to a (correct, just larger) full clone.
+ */
+export declare function gitSupportsSparseCheckout(): boolean;
 /**
  * Run the read-only prerequisite checks for a target. Pure inspection — safe to
  * run unconditionally (Phase-1 advisor calls this before assembling the command).
  */
-export declare function checkPrereqs(target: TargetId): PrereqCheck[];
+export declare function checkPrereqs(target: TargetId, opts?: {
+    bootstrap?: boolean;
+}): PrereqCheck[];
 /** True when every REQUIRED prerequisite passed. */
 export declare function prereqsSatisfied(checks: readonly PrereqCheck[]): boolean;
 //# sourceMappingURL=prereqs.d.ts.map

package/dist/agent/prereqs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prereqs.d.ts","sourceRoot":"","sources":["../../src/agent/prereqs.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AA8BD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,GAAG,WAAW,EAAE,CA8B5D;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAExE"}
+{"version":3,"file":"prereqs.d.ts","sourceRoot":"","sources":["../../src/agent/prereqs.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAqCD,uEAAuE;AACvE,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAGnD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,WAAW,EAAE,CAwChG;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAExE"}

package/dist/agent/prereqs.js

@@ -34,12 +34,39 @@ function awsIdentity() {
         return null;
     return read('aws sts get-caller-identity --query Account --output text');
 }
+/** Parsed `git --version` as [major, minor], or null if git is absent/unparseable. */
+function gitVersion() {
+    const out = read('git --version');
+    const m = out?.match(/(\d+)\.(\d+)/);
+    return m ? [Number(m[1]), Number(m[2])] : null;
+}
+/** True when git is on PATH (required to bootstrap a clone at all). */
+export function gitAvailable() {
+    return gitVersion() !== null;
+}
+/**
+ * Cone `sparse-checkout` (+ `--filter=blob:none`) needs git ≥ 2.27. Below that,
+ * the bootstrap falls back to a (correct, just larger) full clone.
+ */
+export function gitSupportsSparseCheckout() {
+    const v = gitVersion();
+    return v !== null && (v[0] > 2 || (v[0] === 2 && v[1] >= 27));
+}
 /**
  * Run the read-only prerequisite checks for a target. Pure inspection — safe to
  * run unconditionally (Phase-1 advisor calls this before assembling the command).
  */
-export function checkPrereqs(target) {
+export function checkPrereqs(target, opts = {}) {
     const checks = [];
+    // `--repo` bootstrap git-clones the platform repo first → git is required. A
+    // git below 2.27 still works (full-clone fallback), so the version is advisory.
+    if (opts.bootstrap) {
+        const v = gitVersion();
+        checks.push({ name: 'git', ok: v !== null, detail: v ? `on PATH (${v[0]}.${v[1]})` : 'install git', required: true });
+        if (v !== null && !gitSupportsSparseCheckout()) {
+            checks.push({ name: 'git ≥ 2.27', ok: false, detail: 'sparse clone needs git ≥ 2.27 — falling back to a full clone', required: false });
+        }
+    }
     if (target === 'local') {
         checks.push({
             name: 'Docker',
@@ -70,4 +97,4 @@ export function checkPrereqs(target) {
 export function prereqsSatisfied(checks) {
     return checks.every((c) => c.ok || !c.required);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prereqs.js","sourceRoot":"","sources":["../../src/agent/prereqs.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;GAKG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAWzC,gCAAgC;AAChC,SAAS,GAAG,CAAC,GAAW;IACtB,IAAI,CAAC;QACH,QAAQ,CAAC,cAAc,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QAClE,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,6EAA6E;AAC7E,SAAS,IAAI,CAAC,GAAW;IACvB,IAAI,CAAC;QACH,OAAO,QAAQ,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;IAClG,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,aAAa;IACpB,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,2CAA2C,CAAC,KAAK,IAAI,CAAC;AACrF,CAAC;AAED,SAAS,WAAW;IAClB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7B,OAAO,IAAI,CAAC,2DAA2D,CAAC,CAAC;AAC3E,CAAC;AAED,sFAAsF;AACtF,SAAS,UAAU;IACjB,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC;IAClC,MAAM,CAAC,GAAG,GAAG,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IACrC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACjD,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,YAAY;IAC1B,OAAO,UAAU,EAAE,KAAK,IAAI,CAAC;AAC/B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB;IACvC,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC;IACvB,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAChE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,MAAgB,EAAE,OAAgC,EAAE;IAC/E,MAAM,MAAM,GAAkB,EAAE,CAAC;IAEjC,6EAA6E;IAC7E,gFAAgF;IAChF,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC;QACvB,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QACtH,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,yBAAyB,EAAE,EAAE,CAAC;YAC/C,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,8DAA8D,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1I,CAAC;IACH,CAAC;IAED,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;QACvB,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,QAAQ;YACd,EAAE,EAAE,aAAa,EAAE;YACnB,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,qCAAqC;YACpF,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;QAC1B,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,aAAa,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,qCAAqC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3J,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,GAAG,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,kBAAkB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QACjI,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,iBAAiB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7H,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,kEAAkE;IAClE,MAAM,OAAO,GAAG,WAAW,EAAE,CAAC;IAC9B,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,wBAAwB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5H,MAAM,CAAC,IAAI,CAAC;QACV,IAAI,EAAE,iBAAiB;QACvB,EAAE,EAAE,OAAO,KAAK,IAAI;QACpB,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,0BAA0B,OAAO,GAAG,CAAC,CAAC,CAAC,uCAAuC;QAChG,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,gBAAgB,CAAC,MAA8B;IAC7D,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AAClD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Deterministic, READ-ONLY prerequisite checks per target. No LLM, no mutation —\n * every command here only inspects (presence checks, `aws sts get-caller-identity`,\n * `docker info`). This is the kind of thing a script does better than an agent,\n * so it stays deterministic; the LLM is reserved for NL parsing + diagnosis.\n */\n\nimport { execSync } from 'child_process';\nimport type { TargetId } from './targets.js';\n\nexport interface PrereqCheck {\n  readonly name: string;\n  readonly ok: boolean;\n  readonly detail: string;\n  /** A failing required check blocks deployment; advisory ones are warnings. */\n  readonly required: boolean;\n}\n\n/** True if `cmd` is on PATH. */\nfunction has(cmd: string): boolean {\n  try {\n    execSync(`command -v ${cmd}`, { stdio: 'ignore', timeout: 5000 });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Run a read-only command; return its trimmed stdout or null on failure. */\nfunction read(cmd: string): string | null {\n  try {\n    return execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 }).toString().trim();\n  } catch {\n    return null;\n  }\n}\n\nfunction dockerRunning(): boolean {\n  return has('docker') && read('docker info --format \"{{.ServerVersion}}\"') !== null;\n}\n\nfunction awsIdentity(): string | null {\n  if (!has('aws')) return null;\n  return read('aws sts get-caller-identity --query Account --output text');\n}\n\n/** Parsed `git --version` as [major, minor], or null if git is absent/unparseable. */\nfunction gitVersion(): [number, number] | null {\n  const out = read('git --version');\n  const m = out?.match(/(\\d+)\\.(\\d+)/);\n  return m ? [Number(m[1]), Number(m[2])] : null;\n}\n\n/** True when git is on PATH (required to bootstrap a clone at all). */\nexport function gitAvailable(): boolean {\n  return gitVersion() !== null;\n}\n\n/**\n * Cone `sparse-checkout` (+ `--filter=blob:none`) needs git ≥ 2.27. Below that,\n * the bootstrap falls back to a (correct, just larger) full clone.\n */\nexport function gitSupportsSparseCheckout(): boolean {\n  const v = gitVersion();\n  return v !== null && (v[0] > 2 || (v[0] === 2 && v[1] >= 27));\n}\n\n/**\n * Run the read-only prerequisite checks for a target. Pure inspection — safe to\n * run unconditionally (Phase-1 advisor calls this before assembling the command).\n */\nexport function checkPrereqs(target: TargetId, opts: { bootstrap?: boolean } = {}): PrereqCheck[] {\n  const checks: PrereqCheck[] = [];\n\n  // `--repo` bootstrap git-clones the platform repo first → git is required. A\n  // git below 2.27 still works (full-clone fallback), so the version is advisory.\n  if (opts.bootstrap) {\n    const v = gitVersion();\n    checks.push({ name: 'git', ok: v !== null, detail: v ? `on PATH (${v[0]}.${v[1]})` : 'install git', required: true });\n    if (v !== null && !gitSupportsSparseCheckout()) {\n      checks.push({ name: 'git ≥ 2.27', ok: false, detail: 'sparse clone needs git ≥ 2.27 — falling back to a full clone', required: false });\n    }\n  }\n\n  if (target === 'local') {\n    checks.push({\n      name: 'Docker',\n      ok: dockerRunning(),\n      detail: dockerRunning() ? 'daemon reachable' : 'install Docker and start the daemon',\n      required: true,\n    });\n    return checks;\n  }\n\n  if (target === 'minikube') {\n    checks.push({ name: 'Docker', ok: dockerRunning(), detail: dockerRunning() ? 'daemon reachable' : 'install Docker and start the daemon', required: true });\n    checks.push({ name: 'minikube', ok: has('minikube'), detail: has('minikube') ? 'on PATH' : 'install minikube', required: true });\n    checks.push({ name: 'kubectl', ok: has('kubectl'), detail: has('kubectl') ? 'on PATH' : 'install kubectl', required: true });\n    return checks;\n  }\n\n  // ec2 + fargate — both need the AWS CLI with working credentials.\n  const account = awsIdentity();\n  checks.push({ name: 'AWS CLI', ok: has('aws'), detail: has('aws') ? 'on PATH' : 'install the AWS CLI v2', required: true });\n  checks.push({\n    name: 'AWS credentials',\n    ok: account !== null,\n    detail: account ? `authenticated (account ${account})` : 'run `aws configure` / set AWS_PROFILE',\n    required: true,\n  });\n  return checks;\n}\n\n/** True when every REQUIRED prerequisite passed. */\nexport function prereqsSatisfied(checks: readonly PrereqCheck[]): boolean {\n  return checks.every((c) => c.ok || !c.required);\n}\n"]}

package/dist/agent/targets.d.ts

@@ -32,6 +32,11 @@ export interface TargetSpec {
     readonly required: readonly InputSpec[];
     /** Optional inputs, passed through only when provided. */
     readonly optional: readonly InputSpec[];
+    /**
+     * Repo folder(s) this target's deploy needs, for a sparse `--repo` bootstrap.
+     * Combined with COMMON_SPARSE_PATHS and any selected load steps' paths.
+     */
+    readonly sparsePaths: readonly string[];
     /** Post-deploy step to surface (registers admin + loads plugins). */
     readonly postDeploy?: string;
     /** Rough monthly cost (from docs). */
@@ -44,6 +49,40 @@ export interface TargetSpec {
 export declare const TARGETS: Readonly<Record<TargetId, TargetSpec>>;
 export declare const TARGET_IDS: readonly TargetId[];
 export declare function isTargetId(value: unknown): value is TargetId;
+/**
+ * Folders every `--repo` bootstrap needs regardless of target: the orchestration
+ * scripts. Each target's setup.sh + init-platform.sh live in / drive these.
+ * Deliberately minimal — heavier folders (plugins/compliance/samples) are pulled
+ * in only when their post-install option is selected (see LOAD_STEPS).
+ */
+export declare const COMMON_SPARSE_PATHS: readonly string[];
+/**
+ * Opt-in post-install load steps. Each maps a provision `--with-*` flag to the
+ * init-platform env var that enables it AND the repo folder(s) it reads — so the
+ * sparse checkout grows exactly with the selected options.
+ */
+export declare const LOAD_STEPS: readonly [{
+    readonly id: "plugins";
+    readonly flag: "withPlugins";
+    readonly env: "LOAD_PLUGINS";
+    readonly paths: readonly ["deploy/plugins", "deploy/codebuild"];
+}, {
+    readonly id: "compliance";
+    readonly flag: "withCompliance";
+    readonly env: "LOAD_COMPLIANCE";
+    readonly paths: readonly ["deploy/compliance"];
+}, {
+    readonly id: "samples";
+    readonly flag: "withSamples";
+    readonly env: "LOAD_PIPELINES";
+    readonly paths: readonly ["deploy/samples"];
+}];
+export type LoadStepId = (typeof LOAD_STEPS)[number]['id'];
+/**
+ * The de-duplicated set of sparse paths for a target plus the enabled load
+ * steps: common base ∪ target folder(s) ∪ each enabled step's folder(s).
+ */
+export declare function sparsePathsFor(target: TargetId, enabledLoadIds: readonly string[]): string[];
 export interface AssembleResult {
     /** The exact command to run — secrets masked as `***`. */
     readonly command: string;

package/dist/agent/targets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../src/agent/targets.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,KAAK,GAAG,SAAS,CAAC;AAEhE,2DAA2D;AAC3D,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;IACxC,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;IACxC,qEAAqE;IACrE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2BAA2B;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AA0BD,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAiD1D,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,SAAS,QAAQ,EAA4C,CAAC;AAEvF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;CACxC;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5B,cAAc,CAqBhB;AAED,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAOD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,QAAQ,EAChB,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACtE,cAAc,CA0BhB"}
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../src/agent/targets.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,KAAK,GAAG,SAAS,CAAC;AAEhE,2DAA2D;AAC3D,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;IACxC,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,qEAAqE;IACrE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2BAA2B;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AA0BD,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAqD1D,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,SAAS,QAAQ,EAA4C,CAAC;AAEvF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAID;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAmB,CAAC;AAErE;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;EAKb,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAO5F;AAED,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;CACxC;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5B,cAAc,CAqBhB;AAED,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAOD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,QAAQ,EAChB,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACtE,cAAc,CA0BhB"}