@agent-native/core 0.207.1 → 0.207.2-nightly-20261013011333

package/dist/server/visual-edit-bridge-capability.js

@@ -0,0 +1,233 @@
+import crypto from "node:crypto";
+import path from "node:path";
+export const LOCALHOST_BRIDGE_OPERATION_CAPABILITY_FIELD = "bridgeOperationCapability";
+const CAPABILITY_TTL_MS = 120_000;
+const MAX_CLOCK_SKEW_MS = 30_000;
+const MAX_CANONICAL_BODY_BYTES = 8 * 1024 * 1024;
+const MAX_JSON_DEPTH = 64;
+const CAPABILITY_DOMAIN = "agent-native:visual-edit-bridge-operation:v2\0";
+const AUDIENCE_DOMAIN = "agent-native:visual-edit-bridge-audience:v1\0";
+function base64UrlEncode(value) {
+    return (typeof value === "string" ? Buffer.from(value, "utf8") : value)
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/g, "");
+}
+function base64UrlDecode(value) {
+    if (!/^[A-Za-z0-9_-]+$/.test(value))
+        return null;
+    const decoded = Buffer.from(value.replace(/-/g, "+").replace(/_/g, "/") +
+        "=".repeat((4 - (value.length % 4)) % 4), "base64");
+    return base64UrlEncode(decoded) === value ? decoded : null;
+}
+function canonicalJson(value, depth = 0, root = false) {
+    if (depth > MAX_JSON_DEPTH) {
+        throw new Error("bridge capability body exceeds the JSON depth limit");
+    }
+    if (value === null)
+        return "null";
+    if (typeof value === "string" || typeof value === "boolean") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error("bridge capability body contains a non-finite number");
+        }
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        if (Object.getPrototypeOf(value) !== Array.prototype) {
+            throw new Error("bridge capability body contains a non-JSON array");
+        }
+        const keys = Reflect.ownKeys(value);
+        if (keys.length !== value.length + 1 ||
+            keys.some((key) => typeof key !== "string" ||
+                (key !== "length" &&
+                    (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length)))) {
+            throw new Error("bridge capability body contains a non-JSON array");
+        }
+        const items = [];
+        for (let index = 0; index < value.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (!descriptor || !("value" in descriptor)) {
+                throw new Error("bridge capability body contains a non-JSON array");
+            }
+            items.push(canonicalJson(descriptor.value, depth + 1));
+        }
+        return `[${items.join(",")}]`;
+    }
+    if (typeof value !== "object") {
+        throw new Error("bridge capability body contains a non-JSON value");
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error("bridge capability body contains a non-JSON object");
+    }
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key !== "string")) {
+        throw new Error("bridge capability body contains a non-JSON object");
+    }
+    const entries = keys
+        .filter((key) => !(root && key === LOCALHOST_BRIDGE_OPERATION_CAPABILITY_FIELD))
+        .sort()
+        .map((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !("value" in descriptor)) {
+            throw new Error("bridge capability body contains an accessor");
+        }
+        return `${JSON.stringify(key)}:${canonicalJson(descriptor.value, depth + 1)}`;
+    });
+    return `{${entries.join(",")}}`;
+}
+function canonicalBodyHash(body) {
+    if (body === null ||
+        typeof body !== "object" ||
+        Array.isArray(body) ||
+        (Object.getPrototypeOf(body) !== Object.prototype &&
+            Object.getPrototypeOf(body) !== null)) {
+        throw new Error("bridge capability body must be a JSON object");
+    }
+    const canonical = canonicalJson(body, 0, true);
+    if (Buffer.byteLength(canonical, "utf8") > MAX_CANONICAL_BODY_BYTES) {
+        throw new Error("bridge capability body exceeds the size limit");
+    }
+    return base64UrlEncode(crypto.createHash("sha256").update(canonical, "utf8").digest());
+}
+function assertOperation(operation) {
+    if (typeof operation !== "string" ||
+        operation.length === 0 ||
+        operation.length > 512) {
+        throw new Error("bridge capability operation is invalid");
+    }
+}
+function canonicalBridgeRootPath(rootPath) {
+    if (typeof rootPath !== "string" ||
+        rootPath.length === 0 ||
+        rootPath !== rootPath.trim() ||
+        rootPath.length > 32_768) {
+        throw new Error("bridge root path is invalid");
+    }
+    // Use the platform-independent path implementation for the path syntax so
+    // a cloud server and a local Windows CLI derive the same audience.
+    if ((/^[A-Za-z]:[\\/]/.test(rootPath) || rootPath.startsWith("\\\\")) &&
+        path.win32.isAbsolute(rootPath)) {
+        const normalized = path.win32.normalize(rootPath).replace(/\\/g, "/");
+        const canonicalRoot = path.win32.parse(rootPath).root.replace(/\\/g, "/");
+        return normalized.length > canonicalRoot.length
+            ? normalized.replace(/\/+$/, "")
+            : normalized;
+    }
+    if (path.posix.isAbsolute(rootPath)) {
+        const normalized = path.posix.normalize(rootPath);
+        return normalized === "/" ? normalized : normalized.replace(/\/+$/, "");
+    }
+    throw new Error("bridge root path must be absolute");
+}
+export function createLocalhostBridgeAudience(rootPath) {
+    return crypto
+        .createHash("sha256")
+        .update(AUDIENCE_DOMAIN, "utf8")
+        .update(canonicalBridgeRootPath(rootPath), "utf8")
+        .digest("base64url");
+}
+function signPayload(bridgeToken, encodedPayload) {
+    return base64UrlEncode(crypto
+        .createHmac("sha256", bridgeToken)
+        .update(CAPABILITY_DOMAIN, "utf8")
+        .update(encodedPayload, "ascii")
+        .digest());
+}
+export function issueLocalhostBridgeOperationCapability({ bridgeToken, audience, operation, body, issuedAt = Date.now(), }) {
+    if (typeof bridgeToken !== "string" || bridgeToken.length === 0) {
+        throw new Error("bridge token is required");
+    }
+    if (!/^[A-Za-z0-9_-]{43}$/.test(audience)) {
+        throw new Error("bridge capability audience is invalid");
+    }
+    assertOperation(operation);
+    if (!Number.isSafeInteger(issuedAt) || issuedAt <= 0) {
+        throw new Error("bridge capability issuance time is invalid");
+    }
+    const claims = {
+        version: 2,
+        audience,
+        operation,
+        issuedAt,
+        expiresAt: issuedAt + CAPABILITY_TTL_MS,
+        nonce: base64UrlEncode(crypto.randomBytes(32)),
+        bodyHash: canonicalBodyHash(body),
+    };
+    if (!Number.isSafeInteger(claims.expiresAt)) {
+        throw new Error("bridge capability expiration time is invalid");
+    }
+    const encodedPayload = base64UrlEncode(JSON.stringify(claims));
+    return {
+        capability: `${encodedPayload}.${signPayload(bridgeToken, encodedPayload)}`,
+        nonce: claims.nonce,
+        expiresAt: claims.expiresAt,
+    };
+}
+export function verifyLocalhostBridgeOperationCapability({ bridgeToken, audience, operation, body, capability, now = Date.now(), }) {
+    try {
+        if (typeof bridgeToken !== "string" ||
+            bridgeToken.length === 0 ||
+            typeof capability !== "string" ||
+            capability.length > 4096 ||
+            !/^[A-Za-z0-9_-]{43}$/.test(audience) ||
+            !Number.isSafeInteger(now)) {
+            return null;
+        }
+        assertOperation(operation);
+        const segments = capability.split(".");
+        if (segments.length !== 2)
+            return null;
+        const payloadBytes = base64UrlDecode(segments[0] ?? "");
+        const signature = base64UrlDecode(segments[1] ?? "");
+        if (!payloadBytes || !signature || signature.length !== 32)
+            return null;
+        const expectedSignature = base64UrlDecode(signPayload(bridgeToken, segments[0] ?? ""));
+        if (!expectedSignature ||
+            !crypto.timingSafeEqual(signature, expectedSignature)) {
+            return null;
+        }
+        const claims = JSON.parse(payloadBytes.toString("utf8"));
+        if (claims.version !== 2 ||
+            claims.audience !== audience ||
+            claims.operation !== operation ||
+            !Number.isSafeInteger(claims.issuedAt) ||
+            !Number.isSafeInteger(claims.expiresAt) ||
+            typeof claims.nonce !== "string" ||
+            typeof claims.bodyHash !== "string" ||
+            claims.expiresAt !== claims.issuedAt + CAPABILITY_TTL_MS ||
+            claims.issuedAt > now + MAX_CLOCK_SKEW_MS ||
+            claims.expiresAt <= now ||
+            !/^[A-Za-z0-9_-]{43}$/.test(claims.nonce) ||
+            !/^[A-Za-z0-9_-]{43}$/.test(claims.bodyHash)) {
+            return null;
+        }
+        const allowedKeys = [
+            "version",
+            "audience",
+            "operation",
+            "issuedAt",
+            "expiresAt",
+            "nonce",
+            "bodyHash",
+        ];
+        if (Object.keys(claims).length !== allowedKeys.length ||
+            Object.keys(claims).some((key) => !allowedKeys.includes(key))) {
+            return null;
+        }
+        if (canonicalBodyHash(body) !== claims.bodyHash)
+            return null;
+        return {
+            nonce: claims.nonce,
+            expiresAt: claims.expiresAt,
+        };
+        // coercion-ok: malformed capability claims are an explicit authorization denial; null never grants access.
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shared/motion-easing.d.ts

@@ -0,0 +1,6 @@
+export declare function motionEaseVariableName(ease: string): string | null;
+export declare function isMotionEaseVariableReference(ease: string): boolean;
+/** True only for timing functions accepted by the Motion authoring model. */
+export declare function isValidMotionEase(ease: string): boolean;
+/** Resolves Motion variables and spring tokens to easing strings accepted by WAAPI. */
+export declare function resolveMotionEaseForWebAnimations(ease: string, readCssVariable: (name: string) => string): string;

package/dist/shared/motion-easing.js

@@ -0,0 +1,109 @@
+const CSS_NUMBER = String.raw `[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?`;
+const CSS_PERCENTAGE = String.raw `${CSS_NUMBER}%`;
+const MOTION_EASING_VARIABLE_REFERENCE_RE = /^var\(--an-motion-ease-([a-z0-9][a-z0-9-]{0,63})\)$/;
+const SPRING_EASING_RE = /^spring\(\s*([+-]?(?:\d+\.?\d*|\.\d+))\s*(?:,\s*([+-]?(?:\d+\.?\d*|\.\d+))\s*)?\)$/i;
+export function motionEaseVariableName(ease) {
+    const match = MOTION_EASING_VARIABLE_REFERENCE_RE.exec(ease);
+    return match ? `--an-motion-ease-${match[1]}` : null;
+}
+export function isMotionEaseVariableReference(ease) {
+    return motionEaseVariableName(ease) !== null;
+}
+/** True only for timing functions accepted by the Motion authoring model. */
+export function isValidMotionEase(ease) {
+    if (isMotionEaseVariableReference(ease))
+        return true;
+    const value = ease.trim();
+    const keyword = value.toLowerCase();
+    if ([
+        "linear",
+        "ease",
+        "ease-in",
+        "ease-out",
+        "ease-in-out",
+        "step-start",
+        "step-end",
+    ].includes(keyword)) {
+        return true;
+    }
+    const spring = SPRING_EASING_RE.exec(value);
+    if (keyword === "spring")
+        return true;
+    if (spring) {
+        const bounce = Number(spring[1]);
+        const settle = spring[2] === undefined ? 1 : Number(spring[2]);
+        return bounce >= 0 && bounce <= 1 && settle >= 0.05 && settle <= 1;
+    }
+    if (/^spring/i.test(value))
+        return false;
+    const bezier = new RegExp(`^cubic-bezier\\(\\s*(${CSS_NUMBER})\\s*,\\s*(${CSS_NUMBER})\\s*,\\s*(${CSS_NUMBER})\\s*,\\s*(${CSS_NUMBER})\\s*\\)$`, "i").exec(value);
+    if (bezier) {
+        const [, x1, , x2] = bezier;
+        return (Number(x1) >= 0 && Number(x1) <= 1 && Number(x2) >= 0 && Number(x2) <= 1);
+    }
+    const steps = /^steps\(\s*(\d+)\s*(?:,\s*(jump-start|jump-end|jump-none|jump-both|start|end)\s*)?\)$/i.exec(value);
+    if (steps) {
+        const count = Number(steps[1]);
+        const position = steps[2]?.toLowerCase();
+        return (count > 0 &&
+            Number.isSafeInteger(count) &&
+            (position === "jump-none" ? count > 1 : true));
+    }
+    const linear = /^linear\((.*)\)$/i.exec(value);
+    if (!linear)
+        return false;
+    const stops = linear[1].split(",").map((stop) => stop.trim());
+    if (stops.length < 2)
+        return false;
+    return stops.every((stop) => new RegExp(`^${CSS_NUMBER}(?:\\s+${CSS_PERCENTAGE}(?:\\s+${CSS_PERCENTAGE})?)?$`, "i").test(stop));
+}
+/** Resolves Motion variables and spring tokens to easing strings accepted by WAAPI. */
+export function resolveMotionEaseForWebAnimations(ease, readCssVariable) {
+    const variableName = motionEaseVariableName(ease);
+    let resolvedEase = ease;
+    if (variableName) {
+        resolvedEase = readCssVariable(variableName).trim();
+        if (!resolvedEase ||
+            isMotionEaseVariableReference(resolvedEase) ||
+            !isValidMotionEase(resolvedEase)) {
+            throw new TypeError(`Motion easing variable "${variableName}" is not defined or does not resolve to a concrete easing.`);
+        }
+    }
+    if (!isValidMotionEase(resolvedEase)) {
+        throw new TypeError(`"${resolvedEase}" is not a supported motion easing value.`);
+    }
+    const normalized = resolvedEase.trim();
+    if (normalized.toLowerCase() === "spring") {
+        return springToCssLinear(0.25, 1);
+    }
+    const spring = SPRING_EASING_RE.exec(normalized);
+    if (!spring)
+        return resolvedEase;
+    return springToCssLinear(Number(spring[1]), Number(spring[2] ?? 1));
+}
+function springToCssLinear(bounce, settle) {
+    const sampleCount = 16 + Math.round(bounce * 34);
+    const stops = Array.from({ length: sampleCount + 1 }, (_, index) => {
+        const x = index / sampleCount;
+        const value = index === sampleCount ? 1 : sampleSpring(bounce, settle, x);
+        return (Math.round(value * 10_000) / 10_000).toString();
+    });
+    return `linear(${stops.join(", ")})`;
+}
+function sampleSpring(bounce, settle, x) {
+    if (x <= 0)
+        return 0;
+    const u = x / settle;
+    if (u >= 1)
+        return 1;
+    const zeta = Math.min(1, Math.max(0.02, 1 - bounce));
+    const omega = Math.log(1 / 0.001) / zeta;
+    if (zeta >= 1) {
+        return 1 - Math.exp(-omega * u) * (1 + omega * u);
+    }
+    const omegaD = omega * Math.sqrt(1 - zeta * zeta);
+    const decay = Math.exp(-zeta * omega * u);
+    return (1 -
+        decay *
+            (Math.cos(omegaD * u) + ((zeta * omega) / omegaD) * Math.sin(omegaD * u)));
+}

package/dist/shared/motion-source-node-id.d.ts

@@ -0,0 +1,3 @@
+/** Stable ID for a host JSX element within its project-relative source module. */
+export declare function generatedMotionNodeId(modulePath: string, hostElementOrdinal: number): string;
+export declare function isMotionSourceHostElementTag(tagName: string): boolean;

package/dist/shared/motion-source-node-id.js

@@ -0,0 +1,12 @@
+/** Stable ID for a host JSX element within its project-relative source module. */
+export function generatedMotionNodeId(modulePath, hostElementOrdinal) {
+    let hash = 0xcbf29ce484222325n;
+    for (let index = 0; index < modulePath.length; index += 1) {
+        hash ^= BigInt(modulePath.charCodeAt(index));
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return `an-${hash.toString(16).padStart(16, "0")}-${hostElementOrdinal}`;
+}
+export function isMotionSourceHostElementTag(tagName) {
+    return /^[a-z]/.test(tagName) && tagName !== "script" && tagName !== "style";
+}

package/dist/sharing/actions/list-resource-shares.d.ts

@@ -2,6 +2,7 @@ declare const _default: import("../../action.js").ActionDefinition<{
     resourceType: string;
     resourceId: string;
 }, {
+    role?: undefined;
     ownerEmail: any;
     visibility: any;
     shares: any[];
@@ -11,7 +12,6 @@ declare const _default: import("../../action.js").ActionDefinition<{
         supportsGroupShares?: boolean;
     };
     orgId?: undefined;
-    role?: undefined;
     agentReadable?: undefined;
 } | {
     ownerEmail: string;

package/dist/templates/factory/.agents/skills/review-latest-feedback/SKILL.md

@@ -19,7 +19,7 @@ Four phases, in order. Phase 0 comes before any investigation, not after.
    before investigating any of it.
 1. **Answer the people who answered you.** Older open questions first.
 2. **Fix** what the evidence actually proves, at the owning boundary.
-3. **Reply**, under a hard question budget, then recap.
+3. **Reply** with useful questions, then recap.
 
 Output is fixes. Reply in-thread for every workflow reaction added this run;
 continuing work gets a concrete progress reply, and resolved work gets a final
@@ -82,9 +82,13 @@ error message, URL, or visible flow is enough to start tracing its owner; don't
 wait for details that would not change the reproduction attempt. Phase 2's
 local reproduction procedure applies to all defect reports, not only bashes.
 
-If no safe repo-owned fix is evident after that attempt, record the specific
-evidence limit. Ask only a question whose answer could change the reproduction
-or unblock a fix; after four days without an answer, record **Abandoned - no
+If no safe repo-owned fix is evident after reproduction, record the evidence
+limit. For each defect where reporter input changes reproduction or unblocks a
+fix, ask one direct question naming the missing detail or action and why it
+gates the next step. Inspect supplied run IDs, logs, links, and artifacts
+yourself. Keep internal access, config, observability, and deployment gaps
+internal; never ask reporters for developer traces. Do not label the thread
+**Open** instead of asking. After four days unanswered, record **Abandoned - no
 answer in 4 days**.
 
 Use **Skipped** only for non-defects, never breakage. **Open - no question**
@@ -448,9 +452,11 @@ instruction or prompt exception.
 
 ## Phase 3: reply
 
-Thank issue reporters for opening it and Slack reporters for sharing. Give the
-status or ask a useful question. Follow `address-feedback-with-replies` for
-Slack voice. End each Slack reply with `this was sent from a bot.` after its
+Thank issue reporters for opening it and Slack reporters for sharing. Give an
+active status while work continues. If reporter input gates a fix, ask the
+direct question specified in Phase 0; do not substitute **Open**, **pending**,
+or an evidence description. Follow `address-feedback-with-replies` for Slack
+voice. End each Slack reply with `this was sent from a bot.` after its
 plain-language status.
 
 Short replies: say the change, limits, and next step. Link merged PRs and say
@@ -474,32 +480,26 @@ needed. Do not reopen Slack in later runs to reply.
   observations may be silent; merged Slack fixes still get the reply above.
   **Shipped** is for upvoted improvements.
 - **In progress** — name continuing work and its owner; ask nothing.
-- **A question** — subject to the budget below.
+- **A question** — follow the rules below.
 
-Unclaimed scope/noise gets an internal recap row. Ask about an unverified defect
-only when one answer would unblock it; otherwise record **Open - no question**
-once. Cluster duplicates. Before re-reading any thread to reply, apply the Slack
-ownership gate; stay out of marked messages and active human work.
+Unclaimed scope/noise gets an internal recap row. Cluster duplicates. Before
+replying, apply the Slack ownership gate; stay out of marked messages and active
+human work.
 
-### The question budget
+### Ask only answerable questions
 
-**At most three questions per run, across all sources.** Most runs ask zero or
-one.
+Ask one direct question for each distinct blocked defect when the reporter's
+answer or action changes reproduction or unblocks the fix. There is no per-run
+cap; do not replace a useful question with **Open** or an in-progress status.
+Keep one pending question per thread. After an answer, try the fix before asking
+anything else. Never ask for supplied logs/IDs, internal access/config/tooling,
+subjective choices, or details that do not change the next step. If a
+user-visible link or ID alone blocks reproduction, ask for it and say where to
+find it.
 
-So rank before you ask. For each candidate, state: *if I get this answer, I
-can ship the fix.* Ask the three with the strongest answer. If fewer than
-three clear that bar, ask fewer. Everything below the cut is an internal open
-item, not a message.
-
-Never ask for supplied/inspectable evidence, irrelevant IDs/build numbers,
-subjective choices, or internal blockers. If a user-visible link or ID is the
-sole blocker, ask plainly and say where to find it.
-
-At most one clarification question may be pending per thread at a time. Once it
-is answered or resolved, attempt the fix; if that exposes a different required
-detail, ask at most one new, non-repeating question. Never stack questions or
-repeat a pending one. If a needed artifact is inaccessible to you, ask for a
-fresh link - not for its contents again.
+If an answer exposes a different required detail, ask at most one new,
+non-repeating question. If an artifact is inaccessible, request a fresh link,
+not its contents.
 
 ## Verification and identity
 
@@ -563,7 +563,7 @@ Messages: product N · QA N · dev N (total N)
 Deployment cursor: <timestamp> · carried active run IDs/rows: <ids/count>
 Release lanes: N inspected · failed/stale N · target verified N
 Reaction-gated skips: N · claimed N · answered N
-Questions asked: N/3 · Dropped at 4 days: N
+Questions asked: N · Dropped at 4 days: N
 Repeats of a prior Fixed claim: N (each with its earlier thread and failed fix)
 Upvoted items in scope: N (built: N)
 
@@ -576,12 +576,11 @@ Tracker: <sheet/export and bounded range> - N rows enumerated, N ledgers complet
 Unavailable or unverified: ...
 ```
 
-`Open - no question` is a last resort, not a success state. It requires that
-you worked the defect, could not fix it, and could not form a question that would
-unblock it; a run whose ledger is mostly `Open - no question` has under-asked, not
-finished. It keeps our eye and has no checkmark. "Nothing
-matched" is valid only after each source was queried successfully, with the
-cursor stated.
+`Open - no question` follows reproduction when there is no safe fix and no
+reporter answer or action that changes the next step. Ask when reporter input
+unblocks the fix; keep internal access/tooling blockers internal. Mostly open
+ledgers mean under-asking. Keep `👀`, no `✅`. "Nothing matched" is valid only
+after every source was queried successfully and the cursor is stated.
 
 ## Related skills
 

package/dist/triggers/actions/manage-automation.d.ts

@@ -13,8 +13,6 @@ declare const _default: import("../../action.js").ActionDefinition<{
     executionEngine?: string;
     executionCwd?: string;
 }, {
-    deleted?: undefined;
-    enabled?: undefined;
     created: boolean;
     name: string;
     scope: "organization" | "personal";
@@ -25,31 +23,33 @@ declare const _default: import("../../action.js").ActionDefinition<{
     reasoningEffort: "auto" | "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh";
     webhookPath: string;
     nextRun: string;
+    deleted?: undefined;
+    enabled?: undefined;
     executionHostId?: undefined;
     executionEngine?: undefined;
     executionCwd?: undefined;
 } | {
     scope?: undefined;
-    enabled?: undefined;
-    nextRun?: undefined;
     created?: undefined;
     triggerType?: undefined;
     event?: undefined;
     deleted: boolean;
     name: string;
+    enabled?: undefined;
     schedule?: undefined;
     timezone?: undefined;
     reasoningEffort?: undefined;
     executionHostId?: undefined;
     executionEngine?: undefined;
     executionCwd?: undefined;
+    nextRun?: undefined;
     webhookPath?: undefined;
 } | {
     scope?: undefined;
-    deleted?: undefined;
     created?: undefined;
     triggerType?: undefined;
     event?: undefined;
+    deleted?: undefined;
     name: string;
     enabled: boolean;
     schedule: string;

package/dist/vite/client.js

@@ -29,6 +29,7 @@ import { actionTypesPlugin } from "./action-types-plugin.js";
 import { createAgentNativeConfigContext, loadAgentNativeConfigFile, loadWorkspaceAgentNativeConfigFile, readAgentNativeJsonConfig, resolveFirstRunOnboardingBuildReplacement, resolveHarnessBuildReplacement, writeAgentNativeBuildConfigMarker, } from "./agent-native-config-loader.js";
 import { agentsBundlePlugin } from "./agents-bundle-plugin.js";
 import { migrationDiagnosticPlugin } from "./migration-diagnostic-plugin.js";
+import { motionSourceProvenancePlugin } from "./motion-source-provenance-plugin.js";
 import { resolveAgentNativePackageVersions } from "./package-versions.js";
 import { createSentrySourceMapUploadPlugin, isSentrySourceMapUploadEnabled, } from "./sentry-source-maps.js";
 const require = createRequire(import.meta.url);
@@ -3603,6 +3604,7 @@ function createAgentNativePlugins(options, { command, includeReactTransform, use
         : [];
     return [
         migrationDiagnosticPlugin(),
+        motionSourceProvenancePlugin(),
         persistent5xxRecovery(),
         presetMarkerPlugin,
         ssrStubPlugin([

package/dist/vite/motion-source-provenance-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+/** Adds dev-only JSX identity evidence so source edits follow rendered nodes. */
+export declare function motionSourceProvenancePlugin(): Plugin;