@walkeros/cli 4.3.1-next-1784373088875 → 4.3.1

package/dist/index.d.ts

@@ -218,6 +218,15 @@ interface BundleStats {
  * payload by construction.
  */
 declare function buildDataPayload(flowSettings: Flow): Record<string, unknown>;
+/**
+ * Generate a stage 2 entry file for wrapping an ALREADY-embedded skeleton.
+ *
+ * Unlike `generateWebEntry`, this variant imports `__configData` from the
+ * skeleton (instead of inlining a `dataPayload` string). Used by the
+ * publish-time `wrapSkeleton` helper, which runs on a stage 1 skeleton
+ * produced via `bundle({ skipWrapper: true })` — those skeletons already
+ * export `__configData` alongside `wireConfig` and `startFlow`.
+ */
 /**
  * Preview activation wiring. When present and enabled, the generated entry
  * imports the activator from core and lets it decide whether a preview bundle
@@ -9837,8 +9846,6 @@ interface components {
       flowId: string;
       flowSettingsId: string;
       projectId: string;
-      /** @example k9x2m4p7abcd */
-      token: string;
       /** Format: uri */
       bundleUrl: string;
       activationUrl: string | null;
@@ -9893,17 +9900,33 @@ interface components {
       serverFlowName: string | null;
       serverEndpoint: string | null;
       web: components['schemas']['ObserveSessionWeb'];
+      server: components['schemas']['ObserveSessionServer'];
+      /** Format: date-time */
+      expiresAt: string;
+      recordsReceived: number;
       createdBy: string;
       /** Format: date-time */
       createdAt: string;
     };
     ObserveSessionWeb: {
-      previewId: string;
-      token: string;
+      /** Format: uri */
+      activationUrl: string | null;
+      credential: string;
       previewEnabled: boolean;
       /** Format: uri */
       bundleUrl: string;
     } | null;
+    ObserveSessionServer: {
+      /** Format: uri */
+      endpoint: string | null;
+      env: components['schemas']['ObserveSessionServerEnv'];
+    } | null;
+    ObserveSessionServerEnv: {
+      /** Format: uri */
+      WALKEROS_OBSERVER_URL: string;
+      WALKEROS_DEPLOYMENT_ID: string;
+      WALKEROS_INGEST_TOKEN: string;
+    };
     ObserveSessionJourneysResponse: {
       /** @example ses_abc123xyz456 */
       sessionId: string;
@@ -9921,7 +9944,12 @@ interface components {
     CreateObserveSessionRequest: {
       settingsName: string;
       force?: boolean;
+      replace?: boolean;
+      level?: components['schemas']['ObserveLevel'];
+      origins?: string[];
     };
+    /** @enum {string} */
+    ObserveLevel: 'off' | 'standard' | 'trace';
     ObserveSessionHeartbeatResponse: {
       /** @enum {boolean} */
       ok: true;
@@ -11511,24 +11539,13 @@ interface WrapSkeletonOptions {
      * passing both throws.
      */
     previewGrantTargets?: string[];
-    /**
-     * Browser-only: telemetry wiring. When provided, the wrapped bundle
-     * installs an observer built via `createTelemetryObserver` onto
-     * `collector.observers` and forwards FlowState records to `observerUrl`
-     * using `createBatchedPoster`.
-     *
-     * Omit (or pass `level: 'off'`) to ship a bundle with zero telemetry
-     * plumbing. Mutually exclusive with `observe`.
-     */
-    telemetry?: TelemetryBundleOptions;
     /**
      * Browser-only: STATIC observe connect config baked onto the startFlow
      * config. PUBLIC values only (`url` + `binding`, plus optional
      * `flowId`/`level`/`sample` scoping); the runtime connect module reads the
      * per-session credential out-of-band at boot via the `elbObserve` slot.
-     * This is the preview-artifact observation wiring: unlike `telemetry`, it
-     * bakes no ingest token into the emitted bytes. Mutually exclusive with
-     * `telemetry`.
+     * This is the preview-artifact observation wiring: it bakes no ingest
+     * token into the emitted bytes.
      */
     observe?: ObserveWeb;
     /**
@@ -11540,39 +11557,6 @@ interface WrapSkeletonOptions {
     /** Fine-grained minification options, forwarded to esbuild. */
     minifyOptions?: MinifyOptions;
 }
-/**
- * @deprecated Bakes a plaintext ingest token into the emitted (world-readable)
- * bundle bytes. Use `WrapSkeletonOptions.observe` instead: it bakes only
- * public connect values and the per-session credential arrives out-of-band at
- * boot via the `elbObserve` slot. Its only production caller is the app's
- * preview wrap, which moves to `observe` in F3'; this bake path is then
- * retired.
- */
-interface TelemetryBundleOptions {
-    /** Absolute ingest URL. POST receives JSON array of FlowState. */
-    observerUrl: string;
-    /**
-     * Full deployment-scoped trace endpoint, e.g.
-     * `https://observer.example.com/trace/<deploymentId>`. Baked into the bundle
-     * and polled verbatim; the browser never constructs it from a base.
-     *
-     * Optional: when omitted, the bundle wires the observer at a fixed `level`
-     * with no polling. Suits short-lived, URL-opted-in sessions (e.g. a preview
-     * at `level: 'trace'`).
-     */
-    traceUrl?: string;
-    /** Deployment-scoped plaintext token. Sent as `Authorization: Bearer`. */
-    ingestToken: string;
-    /** Used as the `flowId` on every emitted FlowState. */
-    flowId: string;
-    /**
-     * Baseline verbosity. Default 'standard'. Even an 'off' baseline is wired
-     * (as a supplier) so the runtime trace poll can flip it to trace.
-     */
-    level?: 'off' | 'standard' | 'trace';
-    /** Deterministic sample fraction in [0, 1]. Default 1. */
-    sample?: number;
-}
 declare function wrapSkeleton(options: WrapSkeletonOptions): Promise<void>;
 
 declare function createApiClient(): openapi_fetch.Client<paths, `${string}/${string}`>;

package/dist/index.js

@@ -3269,12 +3269,21 @@ export default async function(context = {}) {
 function readObserveConnect(flowSettings, logger) {
   const observe = flowSettings.config?.observe;
   if (!observe) return void 0;
-  const { url, binding } = observe;
+  const { url, binding, level, sample } = observe;
   if (url === void 0 && binding === void 0) return void 0;
   const trimmedUrl = typeof url === "string" ? url.trim() : "";
   const trimmedBinding = typeof binding === "string" ? binding.trim() : "";
   if (trimmedUrl !== "" && trimmedBinding !== "") {
-    return { url: trimmedUrl, binding: trimmedBinding };
+    return {
+      url: trimmedUrl,
+      binding: trimmedBinding,
+      // Same JSON-borne prudence as the pair: only known-shaped public
+      // values reach the emitted literal.
+      ...level === "off" || level === "standard" || level === "trace" ? { level } : {},
+      // Sample is a fraction in [0, 1] per the Flow.Observe contract; the
+      // range test also drops NaN and the infinities.
+      ...typeof sample === "number" && sample >= 0 && sample <= 1 ? { sample } : {}
+    };
   }
   const missing = [
     ...trimmedUrl === "" ? ["url"] : [],
@@ -3297,11 +3306,6 @@ function emitObserveAssignment(observe) {
   config.observe = ${JSON.stringify(literal)};`;
 }
 function generateWebEntry(stage1Path, dataPayload, options = {}) {
-  if (options.observe !== void 0 && options.telemetry !== void 0) {
-    throw new Error(
-      "generateWebEntry: `observe` (bake-nothing connect module) and `telemetry` (baked ingest token) are mutually exclusive observer wirings. Pass `observe` alone; the per-session credential arrives out-of-band at boot instead of being baked."
-    );
-  }
   const assignments = [];
   if (options.windowCollector) {
     assignments.push(
@@ -3322,30 +3326,13 @@ function generateWebEntry(stage1Path, dataPayload, options = {}) {
   }` : "";
   const stage1Specifier = toFileImportSpecifier(stage1Path);
   const observeBlock = options.observe ? emitObserveAssignment(options.observe) : "";
-  const telemetryImport = options.telemetry ? `
-import { createBatchedPoster as __cbp, createTelemetryObserver as __cto } from '@walkeros/core';` : "";
-  const telemetryBlock = options.telemetry ? `
-  // --- Telemetry wiring ---
-  {
-    const __emit = __cbp({
-      url: ${JSON.stringify(options.telemetry.observerUrl)},
-      token: ${JSON.stringify(options.telemetry.ingestToken)},
-    });
-    const __observer = __cto(__emit, {
-      flowId: ${JSON.stringify(options.telemetry.flowId)},
-      level: ${JSON.stringify(options.telemetry.level ?? "standard")},
-      sample: ${JSON.stringify(options.telemetry.sample ?? 1)},
-    });
-    collector.observers.add(__observer);
-    collector.observeLevel = function () { return ${JSON.stringify(options.telemetry.level ?? "standard")}; };
-  }` : "";
-  return `import { startFlow, wireConfig } from '${stage1Specifier}';${telemetryImport}
+  return `import { startFlow, wireConfig } from '${stage1Specifier}';
 
 const __configData = ${dataPayload};
 
 (async () => {
   const config = wireConfig(__configData);${envBlock}${observeBlock}
-  const { collector, elb } = await startFlow(config);${telemetryBlock}${assignmentCode}
+  const { collector, elb } = await startFlow(config);${assignmentCode}
 })();`;
 }
 function generateWrapEntry(stage1Path, options = {}) {
@@ -3361,11 +3348,6 @@ function generateWrapEntry(stage1Path, options = {}) {
       "generateWrapEntry: `preview` (host activator) and `previewGrantTargets` (preview-artifact injection) are mutually exclusive. A host bundle activates a preview; an artifact injects its grant. Pass at most one."
     );
   }
-  if (options.observe !== void 0 && options.telemetry !== void 0) {
-    throw new Error(
-      "generateWrapEntry: `observe` (bake-nothing connect module) and `telemetry` (baked ingest token) are mutually exclusive observer wirings. Pass `observe` alone; the per-session credential arrives out-of-band at boot instead of being baked."
-    );
-  }
   const preview = options.preview;
   const previewEnabled = !!preview?.enabled;
   const previewImport = previewEnabled ? `import { browserSwapActivator } from '@walkeros/core';
@@ -3418,93 +3400,12 @@ ${grantTargets.map((key) => {
     }
   }` : "";
   const stage1Specifier = toFileImportSpecifier(stage1Path);
-  const hasPoll = !!options.telemetry?.traceUrl;
-  const telemetryImport = options.telemetry ? hasPoll ? `
-import { createBatchedPoster as __cbp, createTelemetryObserver as __cto, resolveTelemetryOptions as __cto_resolve } from '@walkeros/core';` : `
-import { createBatchedPoster as __cbp, createTelemetryObserver as __cto } from '@walkeros/core';` : "";
-  const telemetryPoller = options.telemetry && hasPoll ? `
-let __traceUntil = null;
-let __tracePollInFlight = false;
-function __pollTrace() {
-  if (typeof fetch === 'undefined' || __tracePollInFlight) return;
-  __tracePollInFlight = true;
-  // Bound each poll so a stalled trace endpoint can't pin the in-flight guard
-  // forever (and stack concurrent fetches via setInterval).
-  var __ctrl = typeof AbortController !== 'undefined' ? new AbortController() : null;
-  var __t = __ctrl ? setTimeout(function () { __ctrl.abort(); }, 10000) : null;
-  fetch(${JSON.stringify(options.telemetry.traceUrl)}, {
-    headers: { Authorization: ${JSON.stringify(`Bearer ${options.telemetry.ingestToken}`)} },
-    signal: __ctrl ? __ctrl.signal : undefined,
-  })
-    .then(function (__res) {
-      if (!__res || __res.status !== 200) return;
-      return __res.json().then(function (__body) {
-        if (!__body || typeof __body !== 'object') return;
-        var __value = __body.traceUntil;
-        // Mirror the server poller: set on a non-empty string, clear on null,
-        // leave unchanged on anything else. The null path is the disable case
-        // (stop a trace early) and MUST be honored so web deployments can be
-        // turned off without waiting for the old timestamp to lapse.
-        if (typeof __value === 'string' && __value.length > 0) {
-          __traceUntil = __value;
-        } else if (__value === null) {
-          __traceUntil = null;
-        }
-      });
-    })
-    .catch(function () {})
-    .finally(function () {
-      if (__t) clearTimeout(__t);
-      __tracePollInFlight = false;
-    });
-}
-` : "";
-  const telemetryBlock = options.telemetry ? hasPoll ? `
-  // --- Telemetry wiring ---
-  {
-    const __emit = __cbp({
-      url: ${JSON.stringify(options.telemetry.observerUrl)},
-      token: ${JSON.stringify(options.telemetry.ingestToken)},
-    });
-    // Single resolver drives both the observer projection and observeLevel so
-    // the reported level can never drift from what the observer emits.
-    const __resolveTelemetry = () => __cto_resolve({
-      flowId: ${JSON.stringify(options.telemetry.flowId)},
-      observe: {
-        level: ${JSON.stringify(options.telemetry.level ?? "standard")},
-        sample: ${JSON.stringify(options.telemetry.sample ?? 1)},
-      },
-      traceUntil: __traceUntil,
-    });
-    const __observer = __cto(__emit, __resolveTelemetry);
-    collector.observers.add(__observer);
-    collector.observeLevel = function () {
-      const __opts = __resolveTelemetry();
-      return __opts ? __opts.level : 'off';
-    };
-    __pollTrace();
-    setInterval(__pollTrace, 15000 + Math.floor(Math.random() * 5000));
-  }` : `
-  // --- Telemetry wiring ---
-  {
-    const __emit = __cbp({
-      url: ${JSON.stringify(options.telemetry.observerUrl)},
-      token: ${JSON.stringify(options.telemetry.ingestToken)},
-    });
-    const __observer = __cto(__emit, {
-      flowId: ${JSON.stringify(options.telemetry.flowId)},
-      level: ${JSON.stringify(options.telemetry.level ?? "standard")},
-      sample: ${JSON.stringify(options.telemetry.sample ?? 1)},
-    });
-    collector.observers.add(__observer);
-    collector.observeLevel = function () { return ${JSON.stringify(options.telemetry.level ?? "standard")}; };
-  }` : "";
   const observeBlock = options.observe ? emitObserveAssignment(options.observe) : "";
-  return `${previewImport}import { startFlow, wireConfig, __configData } from '${stage1Specifier}';${telemetryImport}
-${telemetryPoller}
+  return `${previewImport}import { startFlow, wireConfig, __configData } from '${stage1Specifier}';
+
 (async () => {${previewBlock}
   const config = wireConfig(__configData);${envBlock}${previewGrantBlock}${observeBlock}
-  const { collector, elb } = await startFlow(config);${telemetryBlock}${assignmentCode}
+  const { collector, elb } = await startFlow(config);${assignmentCode}
 })();`;
 }
 function singleQuoteLiteral(value) {
@@ -8348,7 +8249,7 @@ function validateMapping(input) {
 // src/commands/validate/validators/entry.ts
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
-var CLIENT_HEADER = "walkeros-cli/4.3.1-next-1784373088875";
+var CLIENT_HEADER = "walkeros-cli/4.3.1";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path20, flowConfig) {
   const flows = flowConfig.flows;
@@ -8913,8 +8814,8 @@ import createClient from "openapi-fetch";
 init_config_file();
 import { createHash } from "crypto";
 import semver4 from "semver";
-var bakedContractVersion = true ? "3.1.0" : PLACEHOLDER;
-var bakedContractHash = true ? "d3753dd02864fc19892f74a6a9afddb2081fc7a3f249991a681ae6c5540be650" : "";
+var bakedContractVersion = true ? "4.0.0" : PLACEHOLDER;
+var bakedContractHash = true ? "79c9e2d3bd2a72f1a95ba52742c4acdfe446c3835d5d169654f94e95da0e545e" : "";
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -10227,11 +10128,6 @@ async function wrapSkeleton(options) {
       "wrapSkeleton: `preview` (host activator) and `previewGrantTargets` (preview-artifact injection) are mutually exclusive. Pass at most one."
     );
   }
-  if (options.observe && options.telemetry) {
-    throw new Error(
-      "wrapSkeleton: `observe` (bake-nothing connect module) and `telemetry` (baked ingest token) are mutually exclusive. Pass `observe` alone; the per-session credential arrives out-of-band at boot instead of being baked."
-    );
-  }
   if (options.preview && (typeof options.preview.previewOrigin !== "string" || !/^[a-z0-9.-]+$/.test(options.preview.previewOrigin))) {
     throw new Error(
       `Invalid previewOrigin "${options.preview.previewOrigin}". Must be a bare hostname matching /^[a-z0-9.-]+$/.`
@@ -10243,23 +10139,12 @@ async function wrapSkeleton(options) {
   const absoluteSkeletonPath = path19.resolve(skeletonPath);
   const skeletonText = await fs18.readFile(absoluteSkeletonPath, "utf-8");
   const devExternals = extractDevExternals(skeletonText);
-  const tInput = options.telemetry;
-  const tLevel = tInput?.level ?? "standard";
-  const telemetry = tInput ? {
-    observerUrl: tInput.observerUrl,
-    ingestToken: tInput.ingestToken,
-    flowId: tInput.flowId,
-    level: tLevel,
-    ...tInput.traceUrl !== void 0 ? { traceUrl: tInput.traceUrl } : {},
-    ...tInput.sample !== void 0 ? { sample: tInput.sample } : {}
-  } : void 0;
   const entryText = platform === "browser" ? generateWrapEntry(absoluteSkeletonPath, {
     ...windowCollector ? { windowCollector } : {},
     ...windowElb ? { windowElb } : {},
     ...options.preview ? { preview: options.preview } : {},
     ...options.previewGrantTargets ? { previewGrantTargets: options.previewGrantTargets } : {},
     platform,
-    ...telemetry ? { telemetry } : {},
     ...options.observe ? { observe: options.observe } : {}
   }) : generateWrapEntryServer(absoluteSkeletonPath);
   const entryDir = await fs18.mkdtemp(path19.join(os3.tmpdir(), "walkeros-wrap-"));
@@ -10273,7 +10158,7 @@ async function wrapSkeleton(options) {
       format: "esm",
       platform,
       outfile: outputPath,
-      // Resolve `@walkeros/core` (used by the telemetry block) from the CLI
+      // Resolve `@walkeros/core` (used by the preview activator) from the CLI
       // package's own dependency tree and the workspace root. Without this,
       // esbuild looks under the temp entryDir which has no node_modules.
       // The wrap step always runs from inside the CLI process; both the