@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/chunk-2UZQHDM7.js

@@ -0,0 +1,323 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  getIdentityPersistence,
+  getIdentityWriteOutcome,
+  posthogApiKey,
+  posthogHost,
+  readConfig,
+  telemetryRuntimeOverride,
+  writeConfig
+} from "./chunk-NYEXNSHM.js";
+import {
+  getInvocationId
+} from "./chunk-54HJ63Q2.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  CANARIES,
+  canaryEnvVar,
+  canaryFeatureProperties,
+  evaluateCanary,
+  findCanary,
+  parseCanaryOverride
+} from "./chunk-FXMKHHPO.js";
+import {
+  VERSION
+} from "./chunk-AHX34EFP.js";
+import {
+  getSystemMeta
+} from "./chunk-T6AGUTZJ.js";
+
+// src/telemetry/transport.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+
+// src/utils/hostAnswers.ts
+import { promises as dns } from "dns";
+var PROBE_TIMEOUT_MS = 1e3;
+function fetchGoesThroughEnvProxy() {
+  if (!(process.env["HTTPS_PROXY"] ?? process.env["https_proxy"])?.trim()) return false;
+  const flags = [...process.execArgv, ...process.env["NODE_OPTIONS"]?.split(/\s+/u) ?? []];
+  return process.env["NODE_USE_ENV_PROXY"] === "1" || flags.includes("--use-env-proxy");
+}
+async function hostAnswers(host) {
+  if (fetchGoesThroughEnvProxy()) return true;
+  try {
+    const resolver = new dns.Resolver({ timeout: PROBE_TIMEOUT_MS, tries: 1 });
+    const results = await Promise.allSettled([resolver.resolve4(host), resolver.resolve6(host)]);
+    const anyFamilyTimedOut = results.some(
+      (r) => r.status === "rejected" && r.reason.code === "ETIMEOUT"
+    );
+    return !anyFamilyTimedOut && results.some((r) => r.status === "fulfilled");
+  } catch {
+    return false;
+  }
+}
+
+// src/telemetry/transport.ts
+var FLUSH_TIMEOUT_MS = 5e3;
+var eventQueue = [];
+function enqueue(event, properties, distinctId) {
+  eventQueue.push({
+    uuid: randomUUID(),
+    event,
+    distinctId,
+    properties,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function buildPayload(events) {
+  if (events.length === 0) return null;
+  const config = readConfig();
+  const batch = events.map((e) => ({
+    uuid: e.uuid,
+    event: e.event,
+    properties: { ...e.properties, $ip: null },
+    distinct_id: e.distinctId ?? config.anonymousId,
+    timestamp: e.timestamp
+  }));
+  return JSON.stringify({ api_key: posthogApiKey(), batch });
+}
+var inFlight;
+async function flush() {
+  const run = inFlight ? inFlight.then((sent) => sent ? sendQueued() : false, sendQueued) : sendQueued();
+  const current = run.finally(() => {
+    if (inFlight === current) inFlight = void 0;
+  });
+  inFlight = current;
+  await current;
+}
+async function sendQueued() {
+  const snapshot = eventQueue.slice();
+  const payload = buildPayload(snapshot);
+  if (payload == null) return true;
+  if (!await hostAnswers(new URL(posthogHost()).hostname)) return false;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FLUSH_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${posthogHost()}/batch/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Connection: "close" },
+      body: payload,
+      signal: controller.signal
+    });
+    await res.body?.cancel();
+    const sent = new Set(snapshot);
+    eventQueue = eventQueue.filter((e) => !sent.has(e));
+    return true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function flushSync() {
+  const payload = buildPayload(eventQueue);
+  if (payload == null) return;
+  eventQueue = [];
+  try {
+    const child = spawn(
+      process.execPath,
+      [
+        "-e",
+        `fetch(${JSON.stringify(`${posthogHost()}/batch/`)},{method:"POST",headers:{"Content-Type":"application/json"},body:${JSON.stringify(payload)},signal:AbortSignal.timeout(${FLUSH_TIMEOUT_MS})}).catch(()=>{})`
+      ],
+      { detached: true, stdio: "ignore", windowsHide: true }
+    );
+    child.unref();
+  } catch {
+  }
+}
+
+// src/ui/diagnostics.ts
+var diag = {
+  /** A user-facing notice or progress line (e.g. "Installing … skills…"). */
+  notice(...args) {
+    console.error(...args);
+  },
+  /** A warning the user should see but that isn't fatal. */
+  warn(...args) {
+    console.warn(...args);
+  }
+};
+
+// src/telemetry/canary.ts
+function telemetryActive() {
+  if (telemetryRuntimeOverride() !== null) return false;
+  return readConfig().telemetryEnabled;
+}
+var decisions = /* @__PURE__ */ new Map();
+var decisionsTelemetryPosture;
+function decideCanary(name) {
+  const definition = findCanary(name);
+  if (!definition) return { enabled: false, reason: "out_of_cohort" };
+  const override = parseCanaryOverride(process.env[canaryEnvVar(definition.name)]);
+  if (override === void 0 && !telemetryActive()) {
+    return { enabled: false, reason: "telemetry_opt_out" };
+  }
+  const config = readConfig();
+  return evaluateCanary({
+    feature: definition.name,
+    // The bucket seed, NOT the anonymousId: the seed is inherited across
+    // config.json re-mints via the install-state file, so cohorts hold when
+    // the telemetry id re-rolls. Both files live in ~/.hyperframes, so
+    // deleting that directory clears the cohort too — intentional. Fallback
+    // covers only a failed backfill write on a legacy config.
+    unitId: config.bucketSeed ?? config.anonymousId,
+    percentage: definition.percentage,
+    override,
+    // CI installs regenerate their config per run, so their ids are
+    // ephemeral — they would hop cohorts between runs, adding noise to the
+    // rollout signal while saying nothing about real users. An explicit
+    // override still gets through, which is how you test a canary in CI.
+    exclude: getSystemMeta().is_ci
+  });
+}
+function resolveCanary(name) {
+  const posture = telemetryActive();
+  if (decisionsTelemetryPosture !== posture) {
+    decisions.clear();
+    decisionsTelemetryPosture = posture;
+  }
+  const cached = decisions.get(name);
+  if (cached) return cached;
+  const decision = decideCanary(name);
+  decisions.set(name, decision);
+  return decision;
+}
+function canaryDecisionsForStudio() {
+  const out = {};
+  for (const canary of CANARIES) {
+    const { enabled, reason } = resolveCanary(canary.name);
+    out[canary.name] = {
+      enabled,
+      // Provenance, not decoration. Studio has its own telemetry opt-out that
+      // the CLI cannot see, and it must be able to refuse ordinary cohort
+      // enrolment while still honouring a deliberate `HF_CANARY_*` override.
+      // A bare boolean cannot express that difference, so Studio would have
+      // had to either ignore its own opt-out or drop the override.
+      forced: reason === "forced_on" || reason === "forced_off"
+    };
+  }
+  return out;
+}
+function canaryEventProperties() {
+  return canaryFeatureProperties(
+    CANARIES.map((c2) => {
+      const { enabled, reason } = resolveCanary(c2.name);
+      return { name: c2.name, enabled, reason };
+    })
+  );
+}
+
+// src/telemetry/client.ts
+var telemetryEnabled = null;
+function shouldTrack() {
+  if (telemetryEnabled !== null) return telemetryEnabled;
+  if (telemetryRuntimeOverride() !== null) {
+    telemetryEnabled = false;
+    return false;
+  }
+  const config = readConfig();
+  telemetryEnabled = config.telemetryEnabled;
+  return telemetryEnabled;
+}
+function resetTelemetryPostureCache() {
+  telemetryEnabled = null;
+}
+function trackEvent(event, properties = {}, distinctId) {
+  if (!shouldTrack()) return;
+  const sys = getSystemMeta();
+  enqueue(
+    event,
+    {
+      ...properties,
+      cli_version: VERSION,
+      os: process.platform,
+      arch: process.arch,
+      node_version: process.version,
+      os_release: sys.os_release,
+      cpu_count: sys.cpu_count,
+      cpu_model: sys.cpu_model ?? void 0,
+      cpu_speed: sys.cpu_speed ?? void 0,
+      memory_total_mb: sys.memory_total_mb,
+      is_docker: sys.is_docker,
+      is_ci: sys.is_ci,
+      ci_name: sys.ci_name ?? void 0,
+      is_wsl: sys.is_wsl,
+      is_tty: sys.is_tty,
+      sandbox_runtime: sys.sandbox_runtime ?? void 0,
+      agent_runtime: sys.agent_runtime ?? void 0,
+      execution_harness_hint: sys.execution_harness_hint ?? void 0,
+      // New-agent discovery signals — populated only when agent_runtime is null.
+      agent_hint: sys.agent_hint ?? void 0,
+      term_program: sys.term_program ?? void 0,
+      // Did this install's mint find a previous install's state marker?
+      // The fleet-wide rate of `true` IS the recoverable-churn fraction —
+      // the share of "new" ids that are really a config re-mint on a machine
+      // we already knew. Absent (not false) when the config predates the
+      // marker. Resolved after the shouldTrack guard.
+      install_predecessor_found: readConfig().predecessorFound,
+      // Splits the `true` share above: a machine we knew but whose record we
+      // could not read. Without it a partial disk write is indistinguishable
+      // from a genuinely fresh install. Absent in the normal case.
+      install_state_file_corrupt: readConfig().stateFileCorrupt,
+      // Whether this process's anonymousId can be trusted to survive to the
+      // next run: `durable` (loaded from a preexisting config), `unknown`
+      // (minted+persisted this run — an ephemeral HOME is indistinguishable
+      // from a genuine first run), `process_only` (not persisted). Install-
+      // grain metrics must also consider environment and repeated-day use:
+      // a short-lived container can persist its id between two CLI processes.
+      identity_persistence: getIdentityPersistence(),
+      // Outcome of the identity-establishing config write; absent when that
+      // path did not write (including a durable id loaded from disk).
+      config_write_outcome: getIdentityWriteOutcome(),
+      // Groups one invocation's events even when the install identity is
+      // untrustworthy. Always present, unlike the orchestrator-set run_id.
+      invocation_id: getInvocationId(),
+      // Canary assignments as `$feature/canary-<name>` — PostHog's native flag
+      // property shape, so breakdowns and experiment analysis work on a canary
+      // with nothing configured server-side. On EVERY event, not just renders:
+      // a staged rollout is only as good as the ability to split any metric by
+      // cohort. Resolved after the shouldTrack guard, so opted-out installs
+      // never pay for it. See telemetry/canary.ts.
+      ...canaryEventProperties(),
+      agent_env_hints: sys.agent_env_hints ?? void 0,
+      client: sys.client ?? void 0
+    },
+    distinctId
+  );
+}
+function showTelemetryNotice() {
+  if (!shouldTrack()) return false;
+  const config = readConfig();
+  if (config.telemetryNoticeShown) return false;
+  config.telemetryNoticeShown = true;
+  writeConfig(config);
+  diag.notice();
+  diag.notice(`  ${c.dim("Framey collects anonymous usage data to improve the tool.")}`);
+  diag.notice(`  ${c.dim("File paths and composition content are never collected.")}`);
+  diag.notice(
+    `  ${c.dim("If you sign in to HeyGen, your account (email, or username) is linked to your usage.")}`
+  );
+  diag.notice();
+  diag.notice(`  ${c.dim("Disable anytime:")} ${c.accent("framey telemetry disable")}`);
+  diag.notice();
+  return true;
+}
+
+export {
+  canaryDecisionsForStudio,
+  flush,
+  flushSync,
+  shouldTrack,
+  resetTelemetryPostureCache,
+  trackEvent,
+  showTelemetryNotice
+};

package/vendor/framey/dist/chunk-2X4PQEYM.js

@@ -0,0 +1,34 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// src/commands/lambda/repoRoot.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function repoRoot() {
+  const override = process.env.HYPERFRAMES_REPO_ROOT;
+  if (override) {
+    if (existsSync(resolve(override, "packages", "aws-lambda", "package.json"))) return override;
+    throw new Error(
+      "[hyperframes lambda] HYPERFRAMES_REPO_ROOT is not a hyperframes checkout (no packages/aws-lambda/package.json there). Point it at the repo root, or unset it."
+    );
+  }
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 12; depth++) {
+    if (existsSync(resolve(dir, "packages", "aws-lambda", "package.json"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+
+export {
+  repoRoot
+};

package/vendor/framey/dist/chunk-3422KMTD.js

@@ -0,0 +1,168 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// ../parsers/dist/slideshow.js
+var SLIDESHOW_MANIFEST_VERSION = 1;
+var SLIDESHOW_ISLAND_TYPE = "application/hyperframes-slideshow+json";
+function slideshowIslandRegex(flags = "i") {
+  const escaped = SLIDESHOW_ISLAND_TYPE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const htmlWhitespace = "[\\t\\n\\f\\r ]*";
+  return new RegExp(
+    `<script[^>]*type${htmlWhitespace}=${htmlWhitespace}["']${escaped}["'][^>]*>([\\s\\S]*?)<\\/script>`,
+    flags
+  );
+}
+function parseSlideshowManifest(html) {
+  const re = slideshowIslandRegex("i");
+  const match = re.exec(html);
+  if (!match || match[1] === void 0) return null;
+  const raw = match[1].trim();
+  if (raw.length === 0) return null;
+  const parsed = JSON.parse(raw);
+  if (!isManifest(parsed)) {
+    throw new Error("slideshow island is not a valid SlideshowManifest");
+  }
+  return parsed;
+}
+function isOptionalNumberArray(v) {
+  return v === void 0 || Array.isArray(v) && v.every((n) => typeof n === "number");
+}
+function isOptionalBoolean(v) {
+  return v === void 0 || typeof v === "boolean";
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isHotspotRegion(v) {
+  return isRecord(v) && [v["x"], v["y"], v["w"], v["h"]].every(
+    (coordinate) => typeof coordinate === "number" && Number.isFinite(coordinate)
+  );
+}
+function isSlideHotspot(v) {
+  return isRecord(v) && typeof v["id"] === "string" && typeof v["label"] === "string" && typeof v["target"] === "string" && (v["region"] === void 0 || isHotspotRegion(v["region"]));
+}
+function isSlideRef(v) {
+  if (!isRecord(v)) return false;
+  const r = v;
+  if (typeof r["sceneId"] !== "string") return false;
+  if (!isOptionalNumberArray(r["fragments"])) return false;
+  if (r["hotspots"] !== void 0 && (!Array.isArray(r["hotspots"]) || !r["hotspots"].every(isSlideHotspot)))
+    return false;
+  if (!isOptionalBoolean(r["autoplay"])) return false;
+  return true;
+}
+function isSlideSequence(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const s = v;
+  return typeof s["id"] === "string" && typeof s["label"] === "string" && Array.isArray(s["slides"]) && s["slides"].every(isSlideRef);
+}
+function isManifest(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const o = v;
+  if (!Array.isArray(o["slides"]) || !o["slides"].every(isSlideRef)) return false;
+  if (o["slideSequences"] !== void 0) {
+    if (!Array.isArray(o["slideSequences"]) || !o["slideSequences"].every(isSlideSequence))
+      return false;
+  }
+  return true;
+}
+function missingBoundError(sceneId, missing) {
+  const present = missing === "startTime" ? "endTime" : "startTime";
+  return `slide "${sceneId}" sets ${present} but ${missing} cannot be resolved (no scene "${sceneId}")`;
+}
+function resolveTimeRange(ref, scene, errors) {
+  const { startTime, endTime, sceneId } = ref;
+  if (startTime !== void 0 && endTime !== void 0) {
+    return { start: startTime, end: endTime };
+  }
+  if (startTime === void 0 && endTime === void 0) {
+    if (!scene) {
+      errors.push(`slide references unresolved sceneId "${sceneId}"`);
+      return { start: 0, end: 0 };
+    }
+    return { start: scene.start, end: scene.start + scene.duration };
+  }
+  if (!scene) {
+    const missing = startTime === void 0 ? "startTime" : "endTime";
+    errors.push(missingBoundError(sceneId, missing));
+    const bound = startTime ?? endTime ?? 0;
+    return { start: bound, end: bound };
+  }
+  return {
+    start: startTime ?? scene.start,
+    end: endTime ?? scene.start + scene.duration
+  };
+}
+function validateFragments(sceneId, fragments, start, end, errors) {
+  for (const f of fragments) {
+    if (f < start || f > end) {
+      errors.push(`slide "${sceneId}" fragment ${f} is outside range [${start}, ${end}]`);
+    }
+  }
+}
+function resolveSlide(ref, sceneById, errors) {
+  const scene = sceneById.get(ref.sceneId);
+  const { start, end } = resolveTimeRange(ref, scene, errors);
+  if (ref.startTime !== void 0 && ref.endTime !== void 0 && end <= start) {
+    errors.push(`slide "${ref.sceneId}" has endTime (${end}) <= startTime (${start})`);
+  }
+  const fragments = [...new Set(ref.fragments ?? [])].sort((a, b) => a - b);
+  validateFragments(ref.sceneId, fragments, start, end, errors);
+  return { ...ref, start, end, fragments, hotspots: ref.hotspots ?? [] };
+}
+function resolveSlideshow(manifest, scenes) {
+  const errors = [];
+  const sceneById = new Map(scenes.map((s) => [s.id, s]));
+  const sequences = {};
+  for (const seq of manifest.slideSequences ?? []) {
+    if (Object.prototype.hasOwnProperty.call(sequences, seq.id)) {
+      errors.push(`duplicate slideSequence id "${seq.id}": only the last definition is kept`);
+    }
+    sequences[seq.id] = {
+      id: seq.id,
+      label: seq.label,
+      slides: seq.slides.map((s) => resolveSlide(s, sceneById, errors))
+    };
+  }
+  const slides = manifest.slides.map((s) => resolveSlide(s, sceneById, errors));
+  const allSlides = [...slides, ...Object.values(sequences).flatMap((s) => s.slides)];
+  for (const slide of allSlides) {
+    for (const h of slide.hotspots) {
+      const seq = sequences[h.target];
+      if (!seq) {
+        errors.push(`hotspot "${h.id}" targets unknown sequence "${h.target}"`);
+      } else if (seq.slides.length === 0) {
+        errors.push(`hotspot "${h.id}" targets empty sequence "${h.target}"`);
+      }
+    }
+  }
+  const ordered = [...slides].sort((a, b) => a.start - b.start);
+  for (let i = 1; i < ordered.length; i++) {
+    const prev = ordered[i - 1];
+    const curr = ordered[i];
+    if (prev !== void 0 && curr !== void 0 && curr.start < prev.end) {
+      errors.push(`main-line slides "${prev.sceneId}" and "${curr.sceneId}" overlap`);
+    }
+  }
+  return { resolved: { slides, sequences }, errors };
+}
+function isSceneLikeCompositionId(compositionId) {
+  const normalized = compositionId.trim().toLowerCase();
+  if (!normalized || normalized === "main") return false;
+  if (normalized.includes("caption")) return false;
+  if (normalized.includes("ambient")) return false;
+  return true;
+}
+
+export {
+  SLIDESHOW_MANIFEST_VERSION,
+  SLIDESHOW_ISLAND_TYPE,
+  slideshowIslandRegex,
+  parseSlideshowManifest,
+  resolveSlideshow,
+  isSceneLikeCompositionId
+};

package/vendor/framey/dist/chunk-3FYD4YEK.js

@@ -0,0 +1,72 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+
+// src/commands/lambda/state.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function videoArchitecture(stack) {
+  return stack.videoFunctionName ? "arm64" : void 0;
+}
+var STATE_DIR_NAME = ".hyperframes";
+var STATE_FILE_PREFIX = "lambda-stack-";
+var DEFAULT_STACK_NAME = "hyperframes-default";
+function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
+  return join(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
+}
+function writeStackOutputs(outputs, cwd = process.cwd()) {
+  const path = stateFilePath(outputs.stackName, cwd);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(outputs, null, 2) + "\n");
+  return path;
+}
+function readStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
+  const path = stateFilePath(stackName, cwd);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function deleteStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
+  const path = stateFilePath(stackName, cwd);
+  if (existsSync(path)) rmSync(path);
+}
+function listStackNames(cwd = process.cwd()) {
+  const dir = join(cwd, STATE_DIR_NAME);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((f) => f.startsWith(STATE_FILE_PREFIX) && f.endsWith(".json")).map((f) => f.slice(STATE_FILE_PREFIX.length, -".json".length));
+}
+function requireStack(stackName, cwd = process.cwd()) {
+  const stack = readStackOutputs(stackName, cwd);
+  if (!stack) {
+    const known = listStackNames(cwd);
+    let hint = `Run \`framey lambda deploy${stackName === DEFAULT_STACK_NAME ? "" : ` --stack-name=${stackName}`}\` first.`;
+    if (known.length) {
+      hint += ` Known stacks here: ${known.join(", ")}.`;
+    }
+    console.error(
+      `[framey lambda] no stack state for "${stackName}" at ${stateFilePath(stackName, cwd)}. ${hint}`
+    );
+    failCommand();
+  }
+  return stack;
+}
+
+export {
+  videoArchitecture,
+  DEFAULT_STACK_NAME,
+  stateFilePath,
+  writeStackOutputs,
+  readStackOutputs,
+  deleteStackOutputs,
+  listStackNames,
+  requireStack
+};