@higgsfield/video-editor-mcp 1.0.3 → 1.0.5

package/dist/server.mjs

@@ -25742,11 +25742,11 @@ var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value
 var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
 var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
 var isInputRequiredResult = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && value.resultType === "input_required";
-function assertCompleteRequestPrompt(request2) {
-  if (request2.params.ref.type !== "ref/prompt") throw new TypeError(`Expected CompleteRequestPrompt, but got ${request2.params.ref.type}`);
+function assertCompleteRequestPrompt(request3) {
+  if (request3.params.ref.type !== "ref/prompt") throw new TypeError(`Expected CompleteRequestPrompt, but got ${request3.params.ref.type}`);
 }
-function assertCompleteRequestResourceTemplate(request2) {
-  if (request2.params.ref.type !== "ref/resource") throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request2.params.ref.type}`);
+function assertCompleteRequestResourceTemplate(request3) {
+  if (request3.params.ref.type !== "ref/resource") throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request3.params.ref.type}`);
 }
 var X_MCP_HEADER_KEY = "x-mcp-header";
 var RFC9110_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
@@ -26778,7 +26778,7 @@ var Protocol = class {
     Promise.resolve().then(() => handler === void 0 ? fallback(notification) : handler(notification, codec2)).catch((error51) => this._onerror(/* @__PURE__ */ new Error(`Uncaught error in notification handler: ${error51}`)));
   }
   _onrequest(rawRequest, extra) {
-    const { message: request2, lifted } = liftWireOnlyMaterial(rawRequest, "request");
+    const { message: request3, lifted } = liftWireOnlyMaterial(rawRequest, "request");
     const codec2 = this._negotiatedWireCodec();
     if (extra?.classification === void 0 && this._shouldDropInbound(rawRequest) === "drop") {
       this._onerror(/* @__PURE__ */ new Error(`Dropped inbound request '${rawRequest.method}': not servable on this connection's protocol era`));
@@ -26788,7 +26788,7 @@ var Protocol = class {
     const sendErrorResponse = (code, message, data) => {
       const errorResponse = {
         jsonrpc: "2.0",
-        id: request2.id,
+        id: request3.id,
         error: {
           code,
           message,
@@ -26800,7 +26800,7 @@ var Protocol = class {
     if (extra?.classification !== void 0) {
       const classified = classifiedWireEra(extra.classification);
       if (classified !== codec2.era) {
-        this._onerror(/* @__PURE__ */ new Error(`Era mismatch on inbound request '${request2.method}': classified as ${classified} but this instance serves ${codec2.era}`));
+        this._onerror(/* @__PURE__ */ new Error(`Era mismatch on inbound request '${request3.method}': classified as ${classified} but this instance serves ${codec2.era}`));
         const requested = extra.classification.revision ?? classified;
         sendErrorResponse(ProtocolErrorCode.UnsupportedProtocolVersion, `Unsupported protocol version: ${requested}`, {
           supported: this._supportedProtocolVersions,
@@ -26809,11 +26809,11 @@ var Protocol = class {
         return;
       }
     }
-    if (isSpecRequestMethod(request2.method) && !codec2.hasRequestMethod(request2.method)) {
+    if (isSpecRequestMethod(request3.method) && !codec2.hasRequestMethod(request3.method)) {
       sendErrorResponse(ProtocolErrorCode.MethodNotFound, "Method not found");
       return;
     }
-    const handler = this._requestHandlers.get(request2.method) ?? this.fallbackRequestHandler;
+    const handler = this._requestHandlers.get(request3.method) ?? this.fallbackRequestHandler;
     if (handler === void 0) {
       sendErrorResponse(ProtocolErrorCode.MethodNotFound, "Method not found");
       return;
@@ -26825,21 +26825,21 @@ var Protocol = class {
     }
     const sendNotification = (notification, options) => this._notificationViaCodec(this._resolveOutboundCodec(notification.method), notification, {
       ...options,
-      relatedRequestId: request2.id
+      relatedRequestId: request3.id
     });
     const sendRequest = (r, resultSchema, options) => this._requestWithSchemaViaCodec(this._resolveOutboundCodec(r.method), r, resultSchema, {
       ...options,
-      relatedRequestId: request2.id
+      relatedRequestId: request3.id
     });
     const abortController = new AbortController();
-    this._requestHandlerAbortControllers.set(request2.id, abortController);
+    this._requestHandlerAbortControllers.set(request3.id, abortController);
     const partitionedInputResponses = lifted.inputResponses === void 0 ? void 0 : partitionInputResponses(lifted.inputResponses);
     const baseCtx = {
       sessionId: capturedTransport?.sessionId,
       mcpReq: {
-        id: request2.id,
-        method: request2.method,
-        _meta: request2.params?._meta,
+        id: request3.id,
+        method: request3.method,
+        _meta: request3.params?._meta,
         ...lifted.envelope !== void 0 && { envelope: lifted.envelope },
         ...partitionedInputResponses !== void 0 && { inputResponses: partitionedInputResponses.accepted },
         ...partitionedInputResponses !== void 0 && partitionedInputResponses.droppedKeys.length > 0 && { droppedInputResponseKeys: partitionedInputResponses.droppedKeys },
@@ -26858,20 +26858,20 @@ var Protocol = class {
       http: extra?.authInfo ? { authInfo: extra.authInfo } : void 0
     };
     const ctx = this.buildContext(baseCtx, extra);
-    Promise.resolve().then(() => handler(request2, ctx)).then(async (result) => {
+    Promise.resolve().then(() => handler(request3, ctx)).then(async (result) => {
       if (abortController.signal.aborted) return;
       let encoded;
       try {
-        encoded = codec2.encodeResult(request2.method, result, this._outboundServerInfo());
+        encoded = codec2.encodeResult(request3.method, result, this._outboundServerInfo());
       } catch (error51) {
-        this._onerror(/* @__PURE__ */ new Error(`Failed to encode result for ${request2.method}: ${error51}`));
+        this._onerror(/* @__PURE__ */ new Error(`Failed to encode result for ${request3.method}: ${error51}`));
         sendErrorResponse(ProtocolErrorCode.InternalError, "Internal error");
         return;
       }
       const response = {
         result: encoded,
         jsonrpc: "2.0",
-        id: request2.id
+        id: request3.id
       };
       await capturedTransport?.send(response);
     }, async (error51) => {
@@ -26879,7 +26879,7 @@ var Protocol = class {
       const thrownCode = Number.isSafeInteger(error51["code"]) ? error51["code"] : ProtocolErrorCode.InternalError;
       const errorResponse = {
         jsonrpc: "2.0",
-        id: request2.id,
+        id: request3.id,
         error: {
           code: codec2.encodeErrorCode(thrownCode),
           message: error51.message ?? "Internal error",
@@ -26888,7 +26888,7 @@ var Protocol = class {
       };
       await capturedTransport?.send(errorResponse);
     }).catch((error51) => this._onerror(/* @__PURE__ */ new Error(`Failed to send response: ${error51}`))).finally(() => {
-      if (this._requestHandlerAbortControllers.get(request2.id) === abortController) this._requestHandlerAbortControllers.delete(request2.id);
+      if (this._requestHandlerAbortControllers.get(request3.id) === abortController) this._requestHandlerAbortControllers.delete(request3.id);
     });
   }
   _onprogress(notification) {
@@ -26940,13 +26940,13 @@ var Protocol = class {
   async close() {
     await this._transport?.close();
   }
-  request(request2, schemaOrOptions, maybeOptions) {
-    const codec2 = this._resolveOutboundCodec(request2.method);
-    this._assertOutboundRequestInEra(codec2, request2.method);
-    if (isStandardSchema(schemaOrOptions)) return this._requestWithSchemaViaCodec(codec2, request2, schemaOrOptions, maybeOptions);
-    const validate = codecResultValidator(codec2, request2.method);
-    if (validate === void 0) throw new TypeError(`'${request2.method}' is not a spec method; pass a result schema as the second argument to request().`);
-    return this._requestWithSchemaViaCodec(codec2, request2, validate, schemaOrOptions);
+  request(request3, schemaOrOptions, maybeOptions) {
+    const codec2 = this._resolveOutboundCodec(request3.method);
+    this._assertOutboundRequestInEra(codec2, request3.method);
+    if (isStandardSchema(schemaOrOptions)) return this._requestWithSchemaViaCodec(codec2, request3, schemaOrOptions, maybeOptions);
+    const validate = codecResultValidator(codec2, request3.method);
+    if (validate === void 0) throw new TypeError(`'${request3.method}' is not a spec method; pass a result schema as the second argument to request().`);
+    return this._requestWithSchemaViaCodec(codec2, request3, validate, schemaOrOptions);
   }
   /**
   * The wire codec for this instance's negotiated era — the phase-2 truth:
@@ -27005,17 +27005,17 @@ var Protocol = class {
   * explicit compatibility schemas. Spec methods are still era-gated here:
   * an explicit schema never smuggles a deleted method onto the wire.
   */
-  _requestWithSchema(request2, resultSchema, options) {
-    const codec2 = this._resolveOutboundCodec(request2.method);
-    this._assertOutboundRequestInEra(codec2, request2.method);
-    return this._requestWithSchemaViaCodec(codec2, request2, resultSchema, options);
+  _requestWithSchema(request3, resultSchema, options) {
+    const codec2 = this._resolveOutboundCodec(request3.method);
+    this._assertOutboundRequestInEra(codec2, request3.method);
+    return this._requestWithSchemaViaCodec(codec2, request3, resultSchema, options);
   }
   /**
   * The request funnel proper, keyed by the resolved era codec: the codec
   * owns result decoding (raw-first `resultType` discrimination — V-1 —
   * and the era's lift posture) before the schema validation step.
   */
-  _requestWithSchemaViaCodec(codec2, request2, resultSchema, options) {
+  _requestWithSchemaViaCodec(codec2, request3, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, headers } = options ?? {};
     const flowStartedAt = Date.now();
     let onAbort;
@@ -27029,7 +27029,7 @@ var Protocol = class {
         return;
       }
       if (this._options?.enforceStrictCapabilities === true) try {
-        this.assertCapabilityForMethod(request2.method);
+        this.assertCapabilityForMethod(request3.method);
       } catch (error51) {
         earlyReject(error51);
         return;
@@ -27042,16 +27042,16 @@ var Protocol = class {
       const messageId = this._requestMessageId++;
       cleanupMessageId = messageId;
       const jsonrpcRequest = {
-        ...request2,
+        ...request3,
         jsonrpc: "2.0",
         id: messageId
       };
       if (options?.onprogress) {
         this._progressHandlers.set(messageId, options.onprogress);
         jsonrpcRequest.params = {
-          ...request2.params,
+          ...request3.params,
           _meta: {
-            ...request2.params?._meta,
+            ...request3.params?._meta,
             progressToken: messageId
           }
         };
@@ -27082,7 +27082,7 @@ var Protocol = class {
         if (response instanceof Error) return reject(response);
         let decoded;
         try {
-          decoded = codec2.decodeResult(request2.method, response.result);
+          decoded = codec2.decodeResult(request3.method, response.result);
         } catch (error51) {
           return reject(error51 instanceof Error ? error51 : new Error(String(error51)));
         }
@@ -27091,12 +27091,12 @@ var Protocol = class {
           if (options?.allowInputRequired === true) return resolve3(manualInputRequiredValue(decoded));
           const flow = {
             codec: codec2,
-            request: request2,
+            request: request3,
             resultSchema,
             options,
             flowStartedAt,
-            retry: (params, legOptions) => this._requestWithSchemaViaCodec(codec2, params === void 0 ? { method: request2.method } : {
-              method: request2.method,
+            retry: (params, legOptions) => this._requestWithSchemaViaCodec(codec2, params === void 0 ? { method: request3.method } : {
+              method: request3.method,
               params
             }, resultSchema, legOptions)
           };
@@ -27105,7 +27105,7 @@ var Protocol = class {
         const result = decoded.result;
         validateStandardSchema(resultSchema, result).then((parseResult) => {
           if (parseResult.success) resolve3(parseResult.data);
-          else reject(new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${request2.method}: ${parseResult.error}`));
+          else reject(new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${request3.method}: ${parseResult.error}`));
         }, reject);
       });
       onAbort = () => cancel(options?.signal?.reason);
@@ -27170,18 +27170,18 @@ var Protocol = class {
     let stored;
     if (typeof schemasOrHandler === "function") {
       if (!isSpecRequestMethod(method)) throw new TypeError(`'${method}' is not a spec request method; pass schemas as the second argument to setRequestHandler().`);
-      stored = (request2, ctx) => {
+      stored = (request3, ctx) => {
         const dispatchCodec = this._negotiatedWireCodec();
-        let outcome = dispatchCodec.validateRequest(method, request2);
-        if (!outcome.ok && outcome.reason === "not-in-era") outcome = dispatchCodec.validateInputRequest(method, request2);
+        let outcome = dispatchCodec.validateRequest(method, request3);
+        if (!outcome.ok && outcome.reason === "not-in-era") outcome = dispatchCodec.validateInputRequest(method, request3);
         if (!outcome.ok) {
           if (outcome.reason === "not-in-era") throw new ProtocolError(ProtocolErrorCode.InternalError, `No wire schema for ${method} in the resolved era`);
           throw new Error(outcome.message);
         }
         return Promise.resolve(schemasOrHandler(outcome.value, ctx));
       };
-    } else if (maybeHandler) stored = async (request2, ctx) => {
-      const parsed = await validateStandardSchema(schemasOrHandler.params, { ...request2.params });
+    } else if (maybeHandler) stored = async (request3, ctx) => {
+      const parsed = await validateStandardSchema(schemasOrHandler.params, { ...request3.params });
       if (!parsed.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid params for ${method}: ${parsed.error}`);
       return maybeHandler(parsed.data, ctx);
     };
@@ -34694,7 +34694,7 @@ var LegacyInputRequiredShim = class {
   constructor(_host) {
     this._host = _host;
   }
-  async fulfill(method, handler, request2, ctx, firstResult) {
+  async fulfill(method, handler, request3, ctx, firstResult) {
     const { maxRounds, roundTimeoutMs } = this._host;
     const outerSignal = ctx.mcpReq.signal;
     let current = firstResult;
@@ -34755,7 +34755,7 @@ var LegacyInputRequiredShim = class {
         const decoded = await this._host.verifyRequestState(requestState, ctxNext, method);
         if (decoded !== void 0) ctxNext = withRequestStateValue(ctxNext, decoded);
       }
-      const next = await handler(request2, ctxNext);
+      const next = await handler(request3, ctxNext);
       if (!isInputRequiredResult(next)) return next;
       current = next;
     }
@@ -34845,7 +34845,7 @@ var Server = class extends Protocol {
       for (const [operation2, hint] of Object.entries(options.cacheHints)) if (hint !== void 0) assertValidCacheHint(hint, `cacheHints['${operation2}']`);
       this._cacheHints = options.cacheHints;
     }
-    this.setRequestHandler("initialize", (request2) => this._oninitialize(request2));
+    this.setRequestHandler("initialize", (request3) => this._oninitialize(request3));
     this.setNotificationHandler("notifications/initialized", () => this.oninitialized?.());
     if (modernProtocolVersions(this._supportedProtocolVersions).length > 0) this.setRequestHandler("server/discover", () => this._ondiscover());
     if (this._capabilities.logging) this._registerLoggingHandler();
@@ -34858,9 +34858,9 @@ var Server = class extends Protocol {
   * Migrate to stderr logging (STDIO servers) or OpenTelemetry.
   */
   _registerLoggingHandler() {
-    this.setRequestHandler("logging/setLevel", async (request2, ctx) => {
+    this.setRequestHandler("logging/setLevel", async (request3, ctx) => {
       const transportSessionId = ctx.sessionId || ctx.http?.req?.headers.get("mcp-session-id") || void 0;
-      const { level } = request2.params;
+      const { level } = request3.params;
       const parseResult = parseSchema(LoggingLevelSchema, level);
       if (parseResult.success) this._loggingLevels.set(transportSessionId, parseResult.data);
       return {};
@@ -34934,13 +34934,13 @@ var Server = class extends Protocol {
     if (method !== "tools/call") {
       const cacheHint = this._cacheHints?.[method];
       const isInputRequiredCapable = INPUT_REQUIRED_CAPABLE_METHODS.has(method);
-      if (cacheHint === void 0 && !isInputRequiredCapable) return async (request2, ctx) => {
-        const result = await handler(request2, ctx);
+      if (cacheHint === void 0 && !isInputRequiredCapable) return async (request3, ctx) => {
+        const result = await handler(request3, ctx);
         if (isInputRequiredResult(result)) throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned an input-required result, but only tools/call, prompts/get and resources/read support input_required (protocol revision 2026-07-28)`);
         return result;
       };
-      return async (request2, ctx) => {
-        const result = isInputRequiredCapable ? await this._invokeInputRequiredCapableHandler(method, handler, request2, ctx) : await handler(request2, ctx);
+      return async (request3, ctx) => {
+        const result = isInputRequiredCapable ? await this._invokeInputRequiredCapableHandler(method, handler, request3, ctx) : await handler(request3, ctx);
         if (isInputRequiredResult(result)) {
           if (!isInputRequiredCapable) throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned an input-required result, but only tools/call, prompts/get and resources/read support input_required (protocol revision 2026-07-28)`);
           return result;
@@ -34948,11 +34948,11 @@ var Server = class extends Protocol {
         return cacheHint === void 0 ? result : attachCacheHintFallback(result, cacheHint);
       };
     }
-    return async (request2, ctx) => {
+    return async (request3, ctx) => {
       const codec2 = codecForVersion(this._negotiatedProtocolVersion);
-      const validatedRequest = codec2.validateRequest("tools/call", request2);
+      const validatedRequest = codec2.validateRequest("tools/call", request3);
       if (!validatedRequest.ok) throw new ProtocolError(validatedRequest.reason === "not-in-era" ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams, validatedRequest.reason === "not-in-era" ? "No wire schema for tools/call in the resolved era" : `Invalid tools/call request: ${validatedRequest.message}`);
-      const result = await this._invokeInputRequiredCapableHandler("tools/call", handler, request2, ctx);
+      const result = await this._invokeInputRequiredCapableHandler("tools/call", handler, request3, ctx);
       if (isInputRequiredResult(result)) return result;
       const normalizedResult = normalizeContentlessToolResult(result);
       const validationResult = codec2.validateResult("tools/call", normalizedResult);
@@ -34990,7 +34990,7 @@ var Server = class extends Protocol {
   *   violations per family; `inputRequired.legacyShim: false` restores
   *   the pre-shim loud failure.
   */
-  async _invokeInputRequiredCapableHandler(method, handler, request2, ctx) {
+  async _invokeInputRequiredCapableHandler(method, handler, request3, ctx) {
     const servedModern = this._servedModernEra();
     const rawRequestState = ctx.mcpReq.requestState();
     if (rawRequestState !== void 0 && typeof rawRequestState !== "string") throw new ProtocolError(ProtocolErrorCode.InvalidParams, "Invalid or expired requestState", { reason: "invalid_request_state" });
@@ -35001,7 +35001,7 @@ var Server = class extends Protocol {
     }
     let result;
     try {
-      result = await handler(request2, ctxForHandler);
+      result = await handler(request3, ctxForHandler);
     } catch (error51) {
       if (error51 instanceof ProtocolError && error51.code === ProtocolErrorCode.UrlElicitationRequired) {
         if (!servedModern) throw error51;
@@ -35012,7 +35012,7 @@ var Server = class extends Protocol {
     if (!isInputRequiredResult(result)) return result;
     if (!servedModern) {
       if (!this._inputRequiredServing.legacyShim) throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned an input-required result, but this request is served on protocol revision ${this._negotiatedProtocolVersion ?? LATEST_PROTOCOL_VERSION}, which has no input_required vocabulary`);
-      return await this._legacyInputRequiredShim().fulfill(method, handler, request2, ctxForHandler, result);
+      return await this._legacyInputRequiredShim().fulfill(method, handler, request3, ctxForHandler, result);
     }
     const inputRequests = result.inputRequests;
     const hasInputRequests = inputRequests != null && Object.keys(inputRequests).length > 0;
@@ -35131,10 +35131,10 @@ var Server = class extends Protocol {
         break;
     }
   }
-  async _oninitialize(request2) {
-    const requestedVersion = request2.params.protocolVersion;
-    this._clientCapabilities = request2.params.capabilities;
-    this._clientVersion = request2.params.clientInfo;
+  async _oninitialize(request3) {
+    const requestedVersion = request3.params.protocolVersion;
+    this._clientCapabilities = request3.params.capabilities;
+    this._clientVersion = request3.params.clientInfo;
     const legacyVersions = legacyProtocolVersions(this._supportedProtocolVersions);
     const protocolVersion = legacyVersions.includes(requestedVersion) ? requestedVersion : legacyVersions[0] ?? LATEST_PROTOCOL_VERSION;
     this._negotiatedProtocolVersion = protocolVersion;
@@ -35487,14 +35487,14 @@ var McpServer = class {
       if (tool.outputSchema) toolDefinition.outputSchema = standardSchemaToJsonSchema(tool.outputSchema, "output");
       return toolDefinition;
     }) }));
-    this.server.setRequestHandler("tools/call", async (request2, ctx) => {
-      const tool = this._registeredTools[request2.params.name];
-      if (!tool) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request2.params.name} not found`);
-      if (!tool.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request2.params.name} disabled`);
+    this.server.setRequestHandler("tools/call", async (request3, ctx) => {
+      const tool = this._registeredTools[request3.params.name];
+      if (!tool) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request3.params.name} not found`);
+      if (!tool.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request3.params.name} disabled`);
       try {
-        const args = await this.validateToolInput(tool, request2.params.arguments, request2.params.name);
+        const args = await this.validateToolInput(tool, request3.params.arguments, request3.params.name);
         const result = await this.executeToolHandler(tool, args, ctx);
-        await this.validateToolOutput(tool, result, request2.params.name);
+        await this.validateToolOutput(tool, result, request3.params.name);
         if (isInputRequiredResult(result)) return result;
         return this.server.projectCallToolResult(result, tool.outputSchemaJson);
       } catch (error51) {
@@ -35550,40 +35550,40 @@ var McpServer = class {
     if (this._completionHandlerInitialized) return;
     this.server.assertCanSetRequestHandler("completion/complete");
     this.server.registerCapabilities({ completions: {} });
-    this.server.setRequestHandler("completion/complete", async (request2) => {
-      switch (request2.params.ref.type) {
+    this.server.setRequestHandler("completion/complete", async (request3) => {
+      switch (request3.params.ref.type) {
         case "ref/prompt":
-          assertCompleteRequestPrompt(request2);
-          return this.handlePromptCompletion(request2, request2.params.ref);
+          assertCompleteRequestPrompt(request3);
+          return this.handlePromptCompletion(request3, request3.params.ref);
         case "ref/resource":
-          assertCompleteRequestResourceTemplate(request2);
-          return this.handleResourceCompletion(request2, request2.params.ref);
+          assertCompleteRequestResourceTemplate(request3);
+          return this.handleResourceCompletion(request3, request3.params.ref);
         default:
-          throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid completion reference: ${request2.params.ref}`);
+          throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid completion reference: ${request3.params.ref}`);
       }
     });
     this._completionHandlerInitialized = true;
   }
-  async handlePromptCompletion(request2, ref) {
+  async handlePromptCompletion(request3, ref) {
     const prompt = this._registeredPrompts[ref.name];
     if (!prompt) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
     if (!prompt.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
     if (!prompt.argsSchema) return EMPTY_COMPLETION_RESULT;
-    const field = unwrapOptionalSchema(getSchemaShape(prompt.argsSchema)?.[request2.params.argument.name]);
+    const field = unwrapOptionalSchema(getSchemaShape(prompt.argsSchema)?.[request3.params.argument.name]);
     if (!isCompletable(field)) return EMPTY_COMPLETION_RESULT;
     const completer = getCompleter(field);
     if (!completer) return EMPTY_COMPLETION_RESULT;
-    return createCompletionResult(await completer(request2.params.argument.value, request2.params.context));
+    return createCompletionResult(await completer(request3.params.argument.value, request3.params.context));
   }
-  async handleResourceCompletion(request2, ref) {
+  async handleResourceCompletion(request3, ref) {
     const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
     if (!template) {
       if (this._registeredResources[ref.uri]) return EMPTY_COMPLETION_RESULT;
-      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource template ${request2.params.ref.uri} not found`);
+      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource template ${request3.params.ref.uri} not found`);
     }
-    const completer = template.resourceTemplate.completeCallback(request2.params.argument.name);
+    const completer = template.resourceTemplate.completeCallback(request3.params.argument.name);
     if (!completer) return EMPTY_COMPLETION_RESULT;
-    return createCompletionResult(await completer(request2.params.argument.value, request2.params.context));
+    return createCompletionResult(await completer(request3.params.argument.value, request3.params.context));
   }
   _resourceHandlersInitialized = false;
   setResourceRequestHandlers() {
@@ -35616,13 +35616,13 @@ var McpServer = class {
         ...template.metadata
       })) };
     });
-    this.server.setRequestHandler("resources/read", async (request2, ctx) => {
+    this.server.setRequestHandler("resources/read", async (request3, ctx) => {
       let uri;
       try {
-        uri = new URL(request2.params.uri);
+        uri = new URL(request3.params.uri);
       } catch {
-        throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource URI ${request2.params.uri} is invalid`, {
-          uri: request2.params.uri,
+        throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource URI ${request3.params.uri} is invalid`, {
+          uri: request3.params.uri,
           reason: "invalid_uri"
         });
       }
@@ -35635,7 +35635,7 @@ var McpServer = class {
         const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
         if (variables) return attachCacheHintFallback(await template.readCallback(uri, variables, ctx), template.cacheHint);
       }
-      throw new ResourceNotFoundError(request2.params.uri);
+      throw new ResourceNotFoundError(request3.params.uri);
     });
     this._resourceHandlersInitialized = true;
   }
@@ -35655,11 +35655,11 @@ var McpServer = class {
         _meta: prompt._meta
       };
     }) }));
-    this.server.setRequestHandler("prompts/get", async (request2, ctx) => {
-      const prompt = this._registeredPrompts[request2.params.name];
-      if (!prompt) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request2.params.name} not found`);
-      if (!prompt.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request2.params.name} disabled`);
-      return prompt.handler(request2.params.arguments, ctx);
+    this.server.setRequestHandler("prompts/get", async (request3, ctx) => {
+      const prompt = this._registeredPrompts[request3.params.name];
+      if (!prompt) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request3.params.name} not found`);
+      if (!prompt.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request3.params.name} disabled`);
+      return prompt.handler(request3.params.arguments, ctx);
     });
     this._promptHandlersInitialized = true;
   }
@@ -36260,7 +36260,7 @@ function serveStdio(factory, options = {}) {
     }
     return false;
   };
-  const answerLegacyRejection = (request2, reason, requestedVersion) => {
+  const answerLegacyRejection = (request3, reason, requestedVersion) => {
     const rejection2 = modernOnlyStrictRejection({
       kind: "legacy",
       reason,
@@ -36268,7 +36268,7 @@ function serveStdio(factory, options = {}) {
     }, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
     if (rejection2 === void 0) return Promise.resolve();
     reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection2.cell}): ${rejection2.message}`));
-    return writeErrorResponse(request2.id, rejection2.code, rejection2.message, rejection2.data);
+    return writeErrorResponse(request3.id, rejection2.code, rejection2.message, rejection2.data);
   };
   const onInstanceClosed = (channel) => {
     if (closing || channel === discarding) return;
@@ -38102,8 +38102,8 @@ var Protocol2 = class {
     this._taskStore = _options?.taskStore;
     this._taskMessageQueue = _options?.taskMessageQueue;
     if (this._taskStore) {
-      this.setRequestHandler(GetTaskRequestSchema2, async (request2, extra) => {
-        const task = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
+      this.setRequestHandler(GetTaskRequestSchema2, async (request3, extra) => {
+        const task = await this._taskStore.getTask(request3.params.taskId, extra.sessionId);
         if (!task) {
           throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
         }
@@ -38111,9 +38111,9 @@ var Protocol2 = class {
           ...task
         };
       });
-      this.setRequestHandler(GetTaskPayloadRequestSchema2, async (request2, extra) => {
+      this.setRequestHandler(GetTaskPayloadRequestSchema2, async (request3, extra) => {
         const handleTaskResult = async () => {
-          const taskId = request2.params.taskId;
+          const taskId = request3.params.taskId;
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -38164,9 +38164,9 @@ var Protocol2 = class {
         };
         return await handleTaskResult();
       });
-      this.setRequestHandler(ListTasksRequestSchema2, async (request2, extra) => {
+      this.setRequestHandler(ListTasksRequestSchema2, async (request3, extra) => {
         try {
-          const { tasks, nextCursor } = await this._taskStore.listTasks(request2.params?.cursor, extra.sessionId);
+          const { tasks, nextCursor } = await this._taskStore.listTasks(request3.params?.cursor, extra.sessionId);
           return {
             tasks,
             nextCursor,
@@ -38176,20 +38176,20 @@ var Protocol2 = class {
           throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error51 instanceof Error ? error51.message : String(error51)}`);
         }
       });
-      this.setRequestHandler(CancelTaskRequestSchema2, async (request2, extra) => {
+      this.setRequestHandler(CancelTaskRequestSchema2, async (request3, extra) => {
         try {
-          const task = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
+          const task = await this._taskStore.getTask(request3.params.taskId, extra.sessionId);
           if (!task) {
-            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request2.params.taskId}`);
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request3.params.taskId}`);
           }
           if (isTerminal(task.status)) {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
           }
-          await this._taskStore.updateTaskStatus(request2.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request2.params.taskId);
-          const cancelledTask = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
+          await this._taskStore.updateTaskStatus(request3.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+          this._clearTaskQueue(request3.params.taskId);
+          const cancelledTask = await this._taskStore.getTask(request3.params.taskId, extra.sessionId);
           if (!cancelledTask) {
-            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request2.params.taskId}`);
+            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request3.params.taskId}`);
           }
           return {
             _meta: {},
@@ -38310,14 +38310,14 @@ var Protocol2 = class {
     }
     Promise.resolve().then(() => handler(notification)).catch((error51) => this._onerror(new Error(`Uncaught error in notification handler: ${error51}`)));
   }
-  _onrequest(request2, extra) {
-    const handler = this._requestHandlers.get(request2.method) ?? this.fallbackRequestHandler;
+  _onrequest(request3, extra) {
+    const handler = this._requestHandlers.get(request3.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
-    const relatedTaskId = request2.params?._meta?.[RELATED_TASK_META_KEY2]?.taskId;
+    const relatedTaskId = request3.params?._meta?.[RELATED_TASK_META_KEY2]?.taskId;
     if (handler === void 0) {
       const errorResponse = {
         jsonrpc: "2.0",
-        id: request2.id,
+        id: request3.id,
         error: {
           code: ErrorCode.MethodNotFound,
           message: "Method not found"
@@ -38335,17 +38335,17 @@ var Protocol2 = class {
       return;
     }
     const abortController = new AbortController();
-    this._requestHandlerAbortControllers.set(request2.id, abortController);
-    const taskCreationParams = isTaskAugmentedRequestParams2(request2.params) ? request2.params.task : void 0;
-    const taskStore = this._taskStore ? this.requestTaskStore(request2, capturedTransport?.sessionId) : void 0;
+    this._requestHandlerAbortControllers.set(request3.id, abortController);
+    const taskCreationParams = isTaskAugmentedRequestParams2(request3.params) ? request3.params.task : void 0;
+    const taskStore = this._taskStore ? this.requestTaskStore(request3, capturedTransport?.sessionId) : void 0;
     const fullExtra = {
       signal: abortController.signal,
       sessionId: capturedTransport?.sessionId,
-      _meta: request2.params?._meta,
+      _meta: request3.params?._meta,
       sendNotification: async (notification) => {
         if (abortController.signal.aborted)
           return;
-        const notificationOptions = { relatedRequestId: request2.id };
+        const notificationOptions = { relatedRequestId: request3.id };
         if (relatedTaskId) {
           notificationOptions.relatedTask = { taskId: relatedTaskId };
         }
@@ -38355,7 +38355,7 @@ var Protocol2 = class {
         if (abortController.signal.aborted) {
           throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
         }
-        const requestOptions = { ...options, relatedRequestId: request2.id };
+        const requestOptions = { ...options, relatedRequestId: request3.id };
         if (relatedTaskId && !requestOptions.relatedTask) {
           requestOptions.relatedTask = { taskId: relatedTaskId };
         }
@@ -38366,7 +38366,7 @@ var Protocol2 = class {
         return await this.request(r, resultSchema, requestOptions);
       },
       authInfo: extra?.authInfo,
-      requestId: request2.id,
+      requestId: request3.id,
       requestInfo: extra?.requestInfo,
       taskId: relatedTaskId,
       taskStore,
@@ -38376,16 +38376,16 @@ var Protocol2 = class {
     };
     Promise.resolve().then(() => {
       if (taskCreationParams) {
-        this.assertTaskHandlerCapability(request2.method);
+        this.assertTaskHandlerCapability(request3.method);
       }
-    }).then(() => handler(request2, fullExtra)).then(async (result) => {
+    }).then(() => handler(request3, fullExtra)).then(async (result) => {
       if (abortController.signal.aborted) {
         return;
       }
       const response = {
         result,
         jsonrpc: "2.0",
-        id: request2.id
+        id: request3.id
       };
       if (relatedTaskId && this._taskMessageQueue) {
         await this._enqueueTaskMessage(relatedTaskId, {
@@ -38402,7 +38402,7 @@ var Protocol2 = class {
       }
       const errorResponse = {
         jsonrpc: "2.0",
-        id: request2.id,
+        id: request3.id,
         error: {
           code: Number.isSafeInteger(error51["code"]) ? error51["code"] : ErrorCode.InternalError,
           message: error51.message ?? "Internal error",
@@ -38419,8 +38419,8 @@ var Protocol2 = class {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error51) => this._onerror(new Error(`Failed to send response: ${error51}`))).finally(() => {
-      if (this._requestHandlerAbortControllers.get(request2.id) === abortController) {
-        this._requestHandlerAbortControllers.delete(request2.id);
+      if (this._requestHandlerAbortControllers.get(request3.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request3.id);
       }
     });
   }
@@ -38524,11 +38524,11 @@ var Protocol2 = class {
    *
    * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
    */
-  async *requestStream(request2, resultSchema, options) {
+  async *requestStream(request3, resultSchema, options) {
     const { task } = options ?? {};
     if (!task) {
       try {
-        const result = await this.request(request2, resultSchema, options);
+        const result = await this.request(request3, resultSchema, options);
         yield { type: "result", result };
       } catch (error51) {
         yield {
@@ -38540,7 +38540,7 @@ var Protocol2 = class {
     }
     let taskId;
     try {
-      const createResult = await this.request(request2, CreateTaskResultSchema2, options);
+      const createResult = await this.request(request3, CreateTaskResultSchema2, options);
       if (createResult.task) {
         taskId = createResult.task.taskId;
         yield { type: "taskCreated", task: createResult.task };
@@ -38588,7 +38588,7 @@ var Protocol2 = class {
    *
    * Do not use this method to emit notifications! Use notification() instead.
    */
-  request(request2, resultSchema, options) {
+  request(request3, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
     return new Promise((resolve3, reject) => {
       const earlyReject = (error51) => {
@@ -38600,9 +38600,9 @@ var Protocol2 = class {
       }
       if (this._options?.enforceStrictCapabilities === true) {
         try {
-          this.assertCapabilityForMethod(request2.method);
+          this.assertCapabilityForMethod(request3.method);
           if (task) {
-            this.assertTaskCapability(request2.method);
+            this.assertTaskCapability(request3.method);
           }
         } catch (e) {
           earlyReject(e);
@@ -38612,16 +38612,16 @@ var Protocol2 = class {
       options?.signal?.throwIfAborted();
       const messageId = this._requestMessageId++;
       const jsonrpcRequest = {
-        ...request2,
+        ...request3,
         jsonrpc: "2.0",
         id: messageId
       };
       if (options?.onprogress) {
         this._progressHandlers.set(messageId, options.onprogress);
         jsonrpcRequest.params = {
-          ...request2.params,
+          ...request3.params,
           _meta: {
-            ...request2.params?._meta || {},
+            ...request3.params?._meta || {},
             progressToken: messageId
           }
         };
@@ -38825,8 +38825,8 @@ var Protocol2 = class {
   setRequestHandler(requestSchema, handler) {
     const method = getMethodLiteral(requestSchema);
     this.assertRequestHandlerCapability(method);
-    this._requestHandlers.set(method, (request2, extra) => {
-      const parsed = parseWithCompat(requestSchema, request2);
+    this._requestHandlers.set(method, (request3, extra) => {
+      const parsed = parseWithCompat(requestSchema, request3);
       return Promise.resolve(handler(parsed, extra));
     });
   }
@@ -38941,19 +38941,19 @@ var Protocol2 = class {
       }, { once: true });
     });
   }
-  requestTaskStore(request2, sessionId) {
+  requestTaskStore(request3, sessionId) {
     const taskStore = this._taskStore;
     if (!taskStore) {
       throw new Error("No task store configured");
     }
     return {
       createTask: async (taskParams) => {
-        if (!request2) {
+        if (!request3) {
           throw new Error("No request provided");
         }
-        return await taskStore.createTask(taskParams, request2.id, {
-          method: request2.method,
-          params: request2.params
+        return await taskStore.createTask(taskParams, request3.id, {
+          method: request3.method,
+          params: request3.params
         }, sessionId);
       },
       getTask: async (taskId) => {
@@ -39244,8 +39244,8 @@ var ExperimentalClientTasks = class {
    *
    * @experimental
    */
-  requestStream(request2, resultSchema, options) {
-    return this._client.requestStream(request2, resultSchema, options);
+  requestStream(request3, resultSchema, options) {
+    return this._client.requestStream(request3, resultSchema, options);
   }
 };
 
@@ -39410,8 +39410,8 @@ var Client = class extends Protocol2 {
     }
     const method = methodValue;
     if (method === "elicitation/create") {
-      const wrappedHandler = async (request2, extra) => {
-        const validatedRequest = safeParse3(ElicitRequestSchema2, request2);
+      const wrappedHandler = async (request3, extra) => {
+        const validatedRequest = safeParse3(ElicitRequestSchema2, request3);
         if (!validatedRequest.success) {
           const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
           throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
@@ -39425,7 +39425,7 @@ var Client = class extends Protocol2 {
         if (params.mode === "url" && !supportsUrlMode) {
           throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
         }
-        const result = await Promise.resolve(handler(request2, extra));
+        const result = await Promise.resolve(handler(request3, extra));
         if (params.task) {
           const taskValidationResult = safeParse3(CreateTaskResultSchema2, result);
           if (!taskValidationResult.success) {
@@ -39454,14 +39454,14 @@ var Client = class extends Protocol2 {
       return super.setRequestHandler(requestSchema, wrappedHandler);
     }
     if (method === "sampling/createMessage") {
-      const wrappedHandler = async (request2, extra) => {
-        const validatedRequest = safeParse3(CreateMessageRequestSchema2, request2);
+      const wrappedHandler = async (request3, extra) => {
+        const validatedRequest = safeParse3(CreateMessageRequestSchema2, request3);
         if (!validatedRequest.success) {
           const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
           throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
         }
         const { params } = validatedRequest.data;
-        const result = await Promise.resolve(handler(request2, extra));
+        const result = await Promise.resolve(handler(request3, extra));
         if (params.task) {
           const taskValidationResult = safeParse3(CreateTaskResultSchema2, result);
           if (!taskValidationResult.success) {
@@ -41006,13 +41006,13 @@ var StreamableHTTPClientTransport = class {
       this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
       return;
     }
-    const delay = this._getNextReconnectionDelay(attemptCount);
+    const delay2 = this._getNextReconnectionDelay(attemptCount);
     this._reconnectionTimeout = setTimeout(() => {
       this._startOrAuthSse(options).catch((error51) => {
         this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error51 instanceof Error ? error51.message : String(error51)}`));
         this._scheduleReconnection(options, attemptCount + 1);
       });
-    }, delay);
+    }, delay2);
   }
   _handleSseStream(stream, options, isReconnectable) {
     if (!stream) {
@@ -41515,6 +41515,39 @@ function registerAppResource(server, name, uri, config2, readCallback) {
   );
 }
 
+// src/tools/video-editor-local/auth.ts
+var AUTH_DEADLINE_MS = 4 * 6e4;
+var ERROR_MESSAGE = "Could not connect to Higgsfield. Complete browser sign-in, then try again.";
+var profileSchema = external_exports.object({ id: external_exports.string().regex(/\S/) });
+function createEditorAuth(readProfile) {
+  let state = { status: "idle" };
+  let pending;
+  return {
+    status: () => state,
+    start() {
+      if (pending) return state;
+      state = { status: "pending" };
+      const controller = new AbortController();
+      const timer = setTimeout(() => {
+        state = { status: "error", message: ERROR_MESSAGE };
+        controller.abort();
+      }, AUTH_DEADLINE_MS);
+      timer.unref();
+      pending = Promise.resolve().then(() => readProfile(controller.signal)).then((result) => {
+        if (controller.signal.aborted) return;
+        if (result.isError) throw new Error("Identity lookup failed");
+        state = { status: "ready", profile: profileSchema.parse(result.structuredContent) };
+      }).catch(() => {
+        if (!controller.signal.aborted) state = { status: "error", message: ERROR_MESSAGE };
+      }).finally(() => {
+        clearTimeout(timer);
+        pending = void 0;
+      });
+      return state;
+    }
+  };
+}
+
 // src/tools/video-editor-local/hosted-proxy.ts
 var HOSTED_MCP_URL = "https://openai-mcp.higgsfield.ai/mcp";
 var HOSTED_PANEL_TOOLS = [
@@ -41572,7 +41605,7 @@ function registerHostedProxyTools(server, url2, session = new LocalBrowserSessio
     const previous = connected?.client;
     const next = new Client({
       name: "higgsfield-video-editor-local",
-      version: "1.0.3"
+      version: "1.0.5"
     });
     const transport = new StreamableHTTPClientTransport(new URL(url2), {
       requestInit: { headers: { Authorization: `Bearer ${token}` } }
@@ -41587,6 +41620,43 @@ function registerHostedProxyTools(server, url2, session = new LocalBrowserSessio
       }), 6e4).unref();
     return pending;
   }
+  const identity2 = createEditorAuth(async (signal) => {
+    const token = await session.token();
+    signal.throwIfAborted();
+    const next = new Client({ name: "higgsfield-video-editor-identity", version: "1" });
+    const transport = new StreamableHTTPClientTransport(new URL(url2), {
+      requestInit: { headers: { Authorization: `Bearer ${token}` } }
+    });
+    const abort = () => {
+      void next.close().catch(() => void 0);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      await next.connect(transport, { signal, timeout: 3e4 });
+      return await next.callTool({ name: "get_profile", arguments: {} }, void 0, {
+        signal,
+        timeout: 3e4
+      });
+    } finally {
+      signal.removeEventListener("abort", abort);
+      await next.close().catch(() => void 0);
+    }
+  });
+  registerAppTool(
+    server,
+    "video_editing_auth",
+    {
+      title: "Connect the local video editor",
+      description: "Start or inspect the local editor's Higgsfield sign-in without waiting for the browser.",
+      inputSchema: external_exports.strictObject({ action: external_exports.enum(["start", "status"]) }),
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      _meta: { ui: { visibility: ["app"] } }
+    },
+    async ({ action }) => {
+      const state = action === "start" ? identity2.start() : identity2.status();
+      return { content: [], structuredContent: state };
+    }
+  );
   for (const name of HOSTED_PANEL_TOOLS)
     registerAppTool(
       server,
@@ -41746,7 +41816,7 @@ async function projectName(directory, root, update) {
 
 // src/tools/video-editor-local/index.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { appendFile as appendFile2, link as link3, mkdir as mkdir5, mkdtemp as mkdtemp2, readFile as readFile6, rm as rm5, stat as stat3, writeFile as writeFile5 } from "node:fs/promises";
+import { appendFile, link as link3, mkdir as mkdir5, mkdtemp as mkdtemp2, readFile as readFile6, rm as rm5, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename2, extname, isAbsolute as isAbsolute2, join as join9, relative as relative2, resolve as resolve2 } from "node:path";
 import { execFile as execFile3 } from "node:child_process";
@@ -41822,7 +41892,7 @@ var cspOrigins = [];
 var directCspOrigins = () => cspOrigins;
 var CORS = {
   "access-control-allow-origin": "*",
-  "access-control-allow-methods": "GET, HEAD, POST, OPTIONS",
+  "access-control-allow-methods": "GET, HEAD, POST, PUT, DELETE, OPTIONS",
   "access-control-allow-headers": "range, content-type",
   "access-control-expose-headers": "content-range, content-length, accept-ranges, content-type",
   // An https page reaching loopback (Private Network Access / Local Network Access preflights).
@@ -41935,6 +42005,149 @@ var DirectServer = class {
   }
 };
 
+// src/shared/video-editor-media-import.ts
+var STREAMING_MEDIA_PATH = "api/media/stream";
+var STREAMING_IMPORT_REQUIRED = "This project is still using an older editor backend. Finish its running work, stop that higgsedit dev process, and reopen the project with the updated plugin before importing media.";
+
+// src/tools/video-editor-local/import-media.ts
+var REDIRECTS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function httpsUrl(value) {
+  const url2 = new URL(value);
+  if (url2.protocol !== "https:") throw new Error("Only https URLs can be imported.");
+  return url2;
+}
+async function download(fetcher, start, signal) {
+  let url2 = start;
+  for (let redirects = 0; redirects <= 5; redirects++) {
+    const response = await fetcher(url2, { signal, redirect: "manual" });
+    if (!REDIRECTS.has(response.status)) return response;
+    await response.body?.cancel();
+    const location = response.headers.get("location");
+    if (!location) throw new Error("Download redirect is missing its destination.");
+    url2 = httpsUrl(new URL(location, url2).href);
+  }
+  throw new Error("Download has too many redirects.");
+}
+async function uploadResult(response) {
+  if (response.status === 404) {
+    await response.body?.cancel();
+    throw new Error(STREAMING_IMPORT_REQUIRED);
+  }
+  if (!response.body)
+    throw new Error(`Media upload returned an empty response (${response.status}).`);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > 64 * 1024) throw new Error("Media upload response exceeds 64 KiB.");
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+  let result;
+  try {
+    result = JSON.parse(text);
+  } catch {
+    throw new Error(`Media upload returned invalid JSON (${response.status}).`);
+  }
+  if (typeof result !== "object" || result === null || Array.isArray(result))
+    throw new Error("Media upload returned an invalid result.");
+  const object3 = result;
+  if (!response.ok)
+    throw new Error(
+      typeof object3.error === "string" ? object3.error.slice(0, 1e3) : `Media upload failed (${response.status}).`
+    );
+  return object3;
+}
+async function importMedia(origin, url2, fileName, signal, options = {}) {
+  const parsed = httpsUrl(url2);
+  const name = (fileName ?? decodeURIComponent(parsed.pathname.split("/").at(-1) ?? "")).replace(/[/\\]/g, "_").replace(/^\.+/, "") || "import";
+  if (/\0/.test(name)) throw new Error("The media file name contains a null character.");
+  const endpoint = new URL(`/${STREAMING_MEDIA_PATH}`, origin);
+  endpoint.searchParams.set("name", name);
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal?.reason);
+  signal?.throwIfAborted();
+  signal?.addEventListener("abort", abort, { once: true });
+  const timeout = setTimeout(
+    () => controller.abort(new Error("Media import exceeded its time limit.")),
+    options.timeoutMs ?? 30 * 6e4
+  );
+  timeout.unref();
+  let idle;
+  const touch = () => {
+    clearTimeout(idle);
+    idle = setTimeout(
+      () => controller.abort(new Error("Media import stalled while waiting for data.")),
+      options.idleMs ?? 6e4
+    );
+    idle.unref();
+  };
+  const fetcher = options.fetch ?? fetch;
+  let source;
+  let reader;
+  const cancelRead = () => {
+    void reader?.cancel(controller.signal.reason).catch(() => void 0);
+  };
+  let bytes = 0;
+  try {
+    touch();
+    source = await download(fetcher, parsed, controller.signal);
+    if (!source.ok) throw new Error(`Download failed (${source.status}).`);
+    if (!source.body) throw new Error("Download returned no media body.");
+    reader = source.body.getReader();
+    const sourceReader = reader;
+    controller.signal.addEventListener("abort", cancelRead, { once: true });
+    const body = new ReadableStream({
+      async pull(stream) {
+        try {
+          const { value, done } = await sourceReader.read();
+          controller.signal.throwIfAborted();
+          if (done) return stream.close();
+          bytes += value.byteLength;
+          touch();
+          stream.enqueue(value);
+        } catch (error51) {
+          stream.error(error51);
+        }
+      },
+      cancel(reason) {
+        return sourceReader.cancel(reason);
+      }
+    });
+    const response = await fetcher(endpoint, {
+      method: "POST",
+      body,
+      duplex: "half",
+      signal: controller.signal
+    });
+    const result = await uploadResult(response);
+    if (typeof result.src !== "string" || !result.src.startsWith("./media/") || result.src.slice("./media/".length).split("/").some((part) => !part || part === "." || part === ".." || /[\\\0]/.test(part)) || !Number.isSafeInteger(result.byteSize) || result.byteSize !== bytes)
+      throw new Error("Media upload returned an invalid file result.");
+    return { src: result.src, bytes };
+  } catch (error51) {
+    if (controller.signal.aborted) throw controller.signal.reason;
+    throw error51;
+  } finally {
+    clearTimeout(timeout);
+    clearTimeout(idle);
+    signal?.removeEventListener("abort", abort);
+    controller.abort();
+    controller.signal.removeEventListener("abort", cancelRead);
+    await reader?.cancel().catch(() => void 0);
+    reader?.releaseLock();
+    if (source?.body && !source.body.locked) await source.body.cancel().catch(() => void 0);
+  }
+}
+
 // src/tools/video-editor-local/standalone-resource.ts
 import { readFile as readFile4 } from "node:fs/promises";
 import { join as join5 } from "node:path";
@@ -42032,7 +42245,7 @@ var restyleStyleSchema = external_exports.object({
 });
 
 // src/tools/video-editor-local/standalone-resource.ts
-var packageVersion = "1.0.3";
+var packageVersion = "1.0.5";
 var VIDEO_EDITOR_RESOURCE_URI = packageVersion ? `ui://higgsfield/video-editor-v3-${encodeURIComponent(packageVersion)}.html` : "ui://higgsfield/video-editor-v3.html";
 function panelHtmlPath(env = process.env) {
   return env.VIDEO_EDITOR_LOCAL_HTML?.trim() || join5(import.meta.dirname, "index.html");
@@ -42079,7 +42292,7 @@ function registerPanelResource(server, html2, hosted2 = null) {
 
 // src/tools/video-editor-local/relay.ts
 import { openAsBlob } from "node:fs";
-import { appendFile, mkdtemp, rm as rm3 } from "node:fs/promises";
+import { mkdtemp, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as join6 } from "node:path";
 var MAX_CHUNK = 2 << 20;
@@ -42098,8 +42311,17 @@ async function httpTool(origin, call) {
 function checkPath(path2) {
   if (!path2.startsWith("/") || path2.startsWith("//")) throw new Error(`bad path ${path2}`);
 }
-async function send(origin, method, path2, headers, body) {
-  const res = await fetch(`${origin}${path2}`, { method, headers, ...body ? { body } : {} });
+async function send(origin, method, path2, headers, body, signal) {
+  const res = await fetch(`${origin}${path2}`, {
+    method,
+    headers,
+    signal,
+    ...body ? { body } : {}
+  });
+  if (res.status === 404 && path2.startsWith(`/${STREAMING_MEDIA_PATH}?`)) {
+    await res.body?.cancel();
+    throw new Error(STREAMING_IMPORT_REQUIRED);
+  }
   const bytes = Buffer.from(await res.arrayBuffer());
   if (bytes.length > MAX_CHUNK && res.status !== 206)
     throw new Error(`${path2}: ${bytes.length} bytes without a range; ask for a range`);
@@ -42110,49 +42332,110 @@ async function send(origin, method, path2, headers, body) {
   }
   return { status: res.status, headers: kept, body: bytes.toString("base64") };
 }
-var UPLOAD_STALE_MS = 10 * 6e4;
+function uploadLimit(value, env, fallback) {
+  const limit = value ?? Number(process.env[env] ?? fallback);
+  if (!Number.isSafeInteger(limit) || limit <= 0)
+    throw new Error(`${env} must be a positive integer`);
+  return limit;
+}
 var UploadParts = class {
   open = /* @__PURE__ */ new Map();
-  dir = null;
-  async add(origin, part) {
-    this.dropStale();
+  maxBytes;
+  maxConcurrent;
+  idleMs;
+  totalMs;
+  constructor(limits = {}) {
+    this.maxBytes = uploadLimit(limits.maxBytes, "HIGGSEDIT_MEDIA_MAX_BYTES", 8 * 1024 ** 3);
+    this.maxConcurrent = uploadLimit(limits.maxConcurrent, "HIGGSEDIT_MEDIA_MAX_CONCURRENT", 4);
+    this.idleMs = uploadLimit(limits.idleMs, "HIGGSEDIT_MEDIA_IDLE_MS", 6e4);
+    this.totalMs = uploadLimit(limits.totalMs, "HIGGSEDIT_MEDIA_TOTAL_MS", 30 * 6e4);
+  }
+  async add(origin, part, signal) {
+    if (!/^[\w-]{8,64}$/.test(part.id)) throw new Error("Invalid upload id");
+    checkPath(part.path);
     let upload = this.open.get(part.id);
+    if (upload && (upload.origin !== origin || upload.path !== part.path))
+      throw new Error("Upload belongs to another project or path");
+    if (part.cancel) {
+      if (upload) await this.drop(part.id, upload);
+      return { cancelled: true };
+    }
+    signal?.throwIfAborted();
+    if (upload?.busy)
+      throw new Error("Upload part is already being written; wait before sending the next part");
     if (!upload) {
       if (part.offset !== 0) throw new Error(`upload ${part.id} is unknown; start at offset 0`);
-      checkPath(part.path);
-      this.dir ??= mkdtemp(join6(tmpdir(), "video-editor-upload-"));
-      upload = {
-        file: join6(await this.dir, part.id),
+      if (this.open.size >= this.maxConcurrent)
+        throw new Error("Too many active media uploads; wait for one to finish");
+      const expire = () => {
+        void this.drop(part.id, created).catch(() => void 0);
+      };
+      const created = {
+        origin,
         path: part.path,
         size: 0,
-        touched: Date.now()
+        busy: false,
+        abort: new AbortController(),
+        idle: setTimeout(expire, this.idleMs),
+        total: setTimeout(expire, this.totalMs)
       };
+      created.idle.unref();
+      created.total.unref();
+      upload = created;
       this.open.set(part.id, upload);
     }
-    if (part.path !== upload.path || part.offset !== upload.size) {
-      this.drop(part.id);
-      throw new Error(`upload ${part.id}: expected byte ${upload.size} of ${upload.path}`);
-    }
-    const bytes = Buffer.from(part.part, "base64");
-    await appendFile(upload.file, bytes);
-    upload.size += bytes.length;
-    upload.touched = Date.now();
-    if (!part.last) return { received: upload.size };
-    this.open.delete(part.id);
+    const current = upload;
+    current.busy = true;
+    let complete = false;
+    const cancel = () => current.abort.abort(signal?.reason);
+    signal?.addEventListener("abort", cancel, { once: true });
     try {
-      return await send(origin, "POST", upload.path, new Headers(), await openAsBlob(upload.file));
+      if (part.offset !== current.size)
+        throw new Error(`upload ${part.id}: expected byte ${current.size}`);
+      if (part.part.length > Math.ceil(MAX_CHUNK / 3) * 4)
+        throw new Error("Upload part exceeds 2 MiB");
+      const bytes = Buffer.from(part.part, "base64");
+      if (bytes.toString("base64") !== part.part)
+        throw new Error("Upload part is not valid base64");
+      if (bytes.length > MAX_CHUNK) throw new Error("Upload part exceeds 2 MiB");
+      if (current.size + bytes.length > this.maxBytes)
+        throw new Error(`Upload exceeds ${this.maxBytes} bytes`);
+      current.abort.signal.throwIfAborted();
+      current.directory ??= await mkdtemp(join6(tmpdir(), "video-editor-upload-"));
+      current.abort.signal.throwIfAborted();
+      const file2 = join6(current.directory, "body");
+      await writeFile4(file2, bytes, { flag: "a", mode: 384, signal: current.abort.signal });
+      current.size += bytes.length;
+      current.idle.refresh();
+      if (!part.last) {
+        complete = true;
+        return { received: current.size };
+      }
+      const endpoint = new URL(current.path, origin);
+      if (endpoint.pathname === "/api/media") endpoint.pathname = `/${STREAMING_MEDIA_PATH}`;
+      const result = await send(
+        origin,
+        "POST",
+        endpoint.pathname + endpoint.search,
+        new Headers(),
+        await openAsBlob(file2),
+        current.abort.signal
+      );
+      complete = true;
+      return result;
     } finally {
-      await rm3(upload.file, { force: true });
+      signal?.removeEventListener("abort", cancel);
+      current.busy = false;
+      if (!complete || part.last || current.abort.signal.aborted) await this.drop(part.id, current);
     }
   }
-  drop(id2) {
-    const upload = this.open.get(id2);
-    this.open.delete(id2);
-    if (upload) void rm3(upload.file, { force: true });
-  }
-  dropStale() {
-    const cutoff = Date.now() - UPLOAD_STALE_MS;
-    for (const [id2, upload] of this.open) if (upload.touched < cutoff) this.drop(id2);
+  async drop(id2, upload) {
+    upload.abort.abort(new Error("Media upload cancelled or expired"));
+    clearTimeout(upload.idle);
+    clearTimeout(upload.total);
+    if (upload.busy) return;
+    if (this.open.get(id2) === upload) this.open.delete(id2);
+    if (upload.directory) await rm3(upload.directory, { recursive: true, force: true });
   }
 };
 var reload = (undo) => ({
@@ -42316,11 +42599,71 @@ import {
   rm as rm4,
   stat as stat2,
   utimes,
-  writeFile as writeFile4
+  writeFile as writeFile5
 } from "node:fs/promises";
 import { createServer as createServer3 } from "node:net";
 import { homedir as homedir3 } from "node:os";
 import { join as join8 } from "node:path";
+
+// src/tools/video-editor-local/session-health.ts
+import { setTimeout as delay } from "node:timers/promises";
+var PROBE_MS = 2e3;
+async function request2(origin, path2, timeoutMs, read, method = "GET") {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref();
+  try {
+    const response = await fetch(new URL(path2, origin), { method, signal: controller.signal });
+    return response.ok ? await read(response) : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    controller.abort();
+    clearTimeout(timer);
+  }
+}
+async function waitForDevReady(origin, exited, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let backoff = 50;
+  while (!exited()) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return false;
+    if (await request2(origin, "/api/history", Math.min(PROBE_MS, remaining), async () => true))
+      return !exited();
+    if (exited()) return false;
+    const budget = deadline - Date.now();
+    if (budget <= 0) return false;
+    await delay(Math.min(backoff, budget));
+    if (budget <= backoff) return false;
+    backoff = Math.min(backoff * 2, 1e3);
+  }
+  return false;
+}
+async function requestIdleStop(origin) {
+  return await request2(
+    origin,
+    "/api/idle-stop",
+    1e3,
+    async (response) => {
+      const reader = response.body?.getReader();
+      if (!reader) return false;
+      const chunks = [];
+      let bytes = 0;
+      for (; ; ) {
+        const next = await reader.read();
+        if (next.done) break;
+        bytes += next.value.byteLength;
+        if (bytes > 1024) return false;
+        chunks.push(next.value);
+      }
+      const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      return typeof value === "object" && value !== null && "stopping" in value && value.stopping === true;
+    },
+    "POST"
+  ) === true;
+}
+
+// src/tools/video-editor-local/session.ts
 function localStateDirectory(env = process.env) {
   return env.VIDEO_EDITOR_LOCAL_STATE?.trim() || join8(homedir3(), ".higgsfield", "video-editor-local");
 }
@@ -42328,18 +42671,14 @@ var IDLE_MS = 60 * 60 * 1e3;
 var sessionIdOf = (root) => createHash4("sha256").update(root).digest("hex").slice(0, 16);
 var SESSION_ID = /^[0-9a-f]{16}$/;
 var alive = (pid) => {
-  if (!pid) return false;
+  if (!Number.isSafeInteger(pid) || !pid || pid < 1) return false;
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
-    return false;
+  } catch (error51) {
+    return error51.code !== "ESRCH";
   }
 };
-var answers = (origin) => fetch(`${origin}/api/history`, { signal: AbortSignal.timeout(1e3) }).then(
-  (r) => r.ok,
-  () => false
-);
 var sleep2 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 var freePort = () => new Promise((resolve3, reject) => {
   const server = createServer3();
@@ -42364,18 +42703,24 @@ async function startDev(root) {
   });
   child.unref();
   const origin = `http://127.0.0.1:${port}`;
-  const deadline = Date.now() + READY_MS;
-  while (Date.now() < deadline) {
-    if (await answers(origin)) return { origin, pid: child.pid ?? 0 };
-    if (child.exitCode !== null) break;
-    await sleep2(250);
+  let failed = false;
+  const onError = () => {
+    failed = true;
+  };
+  child.once("error", onError);
+  try {
+    if (await waitForDevReady(
+      origin,
+      () => failed || child.exitCode !== null || child.signalCode !== null,
+      READY_MS
+    ))
+      return { origin, pid: child.pid ?? 0 };
+  } finally {
+    child.removeListener("error", onError);
   }
   child.kill();
   throw new Error(`higgsedit dev did not start for ${root}; run \`higgsedit doctor\``);
 }
-var stopPid = (pid) => {
-  if (pid && pid !== process.pid && alive(pid)) process.kill(pid);
-};
 var parseRecord = (text) => {
   try {
     const record2 = JSON.parse(text);
@@ -42397,14 +42742,14 @@ function createSessionStore(options = {}) {
   const write = async (id2, record2) => {
     await mkdir4(projects, { recursive: true, mode: 448 });
     const temp = `${file2(id2, "json")}.${randomUUID4()}.tmp`;
-    await writeFile4(temp, JSON.stringify(record2), { mode: 384 });
+    await writeFile5(temp, JSON.stringify(record2), { mode: 384 });
     await rename3(temp, file2(id2, "json"));
   };
   const create = async (record2) => {
     await mkdir4(projects, { recursive: true, mode: 448 });
     const target = file2(sessionIdOf(record2.root), "json");
     const temp = `${target}.${randomUUID4()}.tmp`;
-    await writeFile4(temp, JSON.stringify(record2), { mode: 384 });
+    await writeFile5(temp, JSON.stringify(record2), { mode: 384 });
     await link2(temp, target).catch((error51) => {
       if (error51.code !== "EEXIST") throw error51;
     });
@@ -42446,7 +42791,7 @@ function createSessionStore(options = {}) {
     for (; ; ) {
       const body = JSON.stringify({ pid: process.pid, at: Date.now() });
       try {
-        await writeFile4(lock, body, { flag: "wx", mode: 384 });
+        await writeFile5(lock, body, { flag: "wx", mode: 384 });
         break;
       } catch (error51) {
         if (error51.code !== "EEXIST") throw error51;
@@ -42480,72 +42825,114 @@ function createSessionStore(options = {}) {
     const used = file2(id2, "used");
     const time3 = new Date(at);
     await utimes(used, time3, time3).catch(async () => {
-      await writeFile4(used, "", { mode: 384 });
+      await writeFile5(used, "", { mode: 384 });
       await utimes(used, time3, time3);
     });
   };
-  const usedAt = async (record2) => (await stat2(file2(sessionIdOf(record2.root), "used")).catch(() => null))?.mtimeMs ?? record2.openedAt;
+  const usedAt = async (record2) => {
+    const id2 = sessionIdOf(record2.root);
+    const written = (await stat2(file2(id2, "used")).catch(() => null))?.mtimeMs ?? record2.openedAt;
+    return Math.max(written, touched.get(id2) ?? -Infinity);
+  };
+  const activityDirectory = (id2) => join8(projects, `${id2}.activity`);
+  const hasActivity = async (id2) => {
+    const names = await readdir2(activityDirectory(id2)).catch((error51) => {
+      if (error51.code === "ENOENT") return [];
+      throw error51;
+    });
+    for (const name of names) {
+      const owner = /^([1-9]\d*)-[0-9a-f-]{36}$/.exec(name);
+      if (!owner || alive(Number(owner[1]))) return true;
+      await rm4(join8(activityDirectory(id2), name), { force: true });
+    }
+    return false;
+  };
+  const recentRecords = async () => {
+    const all = await records();
+    const live = await Promise.all(all.map((record2) => hasProjectFile(record2.root)));
+    return all.filter((_, i) => live[i]).slice(0, RECENT);
+  };
   const session = async (root, origin) => ({
     root,
     id: sessionIdOf(root),
     name: await projectName(directory, root),
     origin
   });
-  const healthy = async (record2, cli) => Boolean(record2?.origin && record2.cli === cli && alive(record2.pid)) && await answers(record2.origin);
-  const stopIdle = async (keep) => {
+  const running = (record2) => Boolean(record2?.origin && alive(record2.pid));
+  const stopIdle = async () => {
     const live = (await records()).filter((record2) => record2.origin && alive(record2.pid));
     const cutoff = now() - idleMs;
-    const idle = (await Promise.all(
-      live.filter((record2) => sessionIdOf(record2.root) !== keep).map(async (record2) => ({ record: record2, used: await usedAt(record2) }))
-    )).filter(({ used }) => used < cutoff);
+    const idle = (await Promise.all(live.map(async (record2) => ({ record: record2, used: await usedAt(record2) })))).filter(({ used }) => used < cutoff);
     for (const { record: record2 } of idle) {
       const id2 = sessionIdOf(record2.root);
       await locked(id2, async () => {
         const saved = await read(id2);
-        if (!saved?.origin || await usedAt(saved) >= cutoff) return;
-        stopPid(saved.pid);
+        if (!saved?.origin || await usedAt(saved) >= cutoff || await hasActivity(id2)) return;
+        if (!await requestIdleStop(saved.origin)) return;
         await write(id2, { root: saved.root, openedAt: saved.openedAt });
+        touched.delete(id2);
       });
     }
   };
+  let sweeping;
+  const sweep = () => {
+    if (sweeping) return sweeping;
+    const pending = stopIdle();
+    sweeping = pending;
+    const done = () => {
+      if (sweeping === pending) sweeping = void 0;
+    };
+    void pending.then(done, done);
+    return pending;
+  };
   const chains = /* @__PURE__ */ new Map();
   const serialized = (id2, run) => {
     const next = (chains.get(id2) ?? Promise.resolve()).then(run, run);
-    chains.set(
-      id2,
-      next.catch(() => {
-      })
+    const settled = next.then(
+      () => void 0,
+      () => void 0
     );
+    chains.set(id2, settled);
+    void settled.then(() => {
+      if (chains.get(id2) === settled) chains.delete(id2);
+    });
     return next;
   };
+  const reading = /* @__PURE__ */ new Map();
   const ensure = (root, opened) => {
     const id2 = sessionIdOf(root);
-    return serialized(id2, async () => {
-      const cli = currentCli();
+    const pending = !opened && reading.get(id2);
+    if (pending) return pending;
+    const work = serialized(id2, async () => {
       let saved = await read(id2);
-      let started = false;
-      if (opened || !await healthy(saved, cli))
+      if (opened || !running(saved))
         saved = await locked(id2, async () => {
           const current = await read(id2);
           const openedAt = opened ? now() : current?.openedAt ?? now();
           let record2;
-          if (await healthy(current, cli)) {
+          if (running(current)) {
             record2 = { ...current, openedAt };
             if (opened) await write(id2, record2);
           } else {
-            stopPid(current?.pid);
+            const cli = currentCli();
             if (opened) await write(id2, { root, openedAt });
             record2 = { root, ...await start(root), cli, openedAt };
             await write(id2, record2);
-            started = true;
           }
           await touch(id2, true);
           return record2;
         });
       else await touch(id2);
-      if (started) await stopIdle(id2);
       return session(root, saved.origin);
     });
+    if (!opened) {
+      reading.set(id2, work);
+      const done = () => {
+        if (reading.get(id2) === work) reading.delete(id2);
+      };
+      void work.then(done, done);
+    }
+    return work;
   };
   const locate = async (ref) => {
     if (ref && SESSION_ID.test(ref)) {
@@ -42563,17 +42950,41 @@ function createSessionStore(options = {}) {
   const store = {
     roots,
     /** Stops dev servers unused for an hour; the MCP server runs this on a timer. */
-    stopIdle: () => stopIdle(),
+    stopIdle: sweep,
     /** A project's dev server origin as last written, without a health check: the direct route reads it per request. */
     peek(id2) {
       if (!SESSION_ID.test(id2)) return null;
       try {
         const saved = parseRecord(readFileSync2(file2(id2, "json"), "utf8"));
-        return saved?.origin && alive(saved.pid) ? { origin: saved.origin } : null;
+        if (!running(saved)) return null;
+        void touch(id2).catch(() => void 0);
+        return { origin: saved.origin };
       } catch {
         return null;
       }
     },
+    /** Pins an operation across MCP processes without heartbeat timers; crashes release on the next sweep. */
+    async withActivity(current, run) {
+      const lease = await locked(current.id, async () => {
+        const saved = await read(current.id);
+        if (!running(saved) || saved.origin !== current.origin)
+          throw new Error(
+            "The local project server changed before this operation. Retry the operation."
+          );
+        const directory2 = activityDirectory(current.id);
+        await mkdir4(directory2, { recursive: true, mode: 448 });
+        const path2 = join8(directory2, `${process.pid}-${randomUUID4()}`);
+        await writeFile5(path2, "", { flag: "wx", mode: 384 });
+        return path2;
+      });
+      try {
+        await touch(current.id, true);
+        return await run();
+      } finally {
+        await rm4(lease, { force: true });
+        await touch(current.id, true);
+      }
+    },
     async open(path2) {
       const root = await resolveProjectDir(path2, roots());
       await migrated();
@@ -42603,9 +43014,16 @@ function createSessionStore(options = {}) {
     },
     /** Recently opened folders that still hold a project, newest first. */
     async recent() {
-      const all = (await records()).map((record2) => record2.root);
-      const live = await Promise.all(all.map(hasProjectFile));
-      return all.filter((_, i) => live[i]).slice(0, RECENT);
+      return (await recentRecords()).map((record2) => record2.root);
+    },
+    /** `recent()` with each folder's last activity: its dev server's last use, else its last open. */
+    async recentActivity() {
+      return Promise.all(
+        (await recentRecords()).map(async (record2) => ({
+          root: record2.root,
+          usedAt: await usedAt(record2)
+        }))
+      );
     },
     /** Projects whose dev server is running, newest opened first; no health check. */
     async live() {
@@ -42794,11 +43212,14 @@ function registerVideoEditorLocalTools(server, options = {}) {
   };
   const scoped = (project, run) => guarded(async () => {
     const session = await store.session(project);
-    return withProject(await run(session), await naming(session, project));
+    return withProject(
+      await store.withActivity(session, () => run(session)),
+      await naming(session, project)
+    );
   });
   const mediaScoped = (project, run) => guarded(async () => {
     const session = project ? await store.session(project) : await store.find().catch(() => null);
-    const result = await run(session?.root);
+    const result = session ? await store.withActivity(session, () => run(session.root)) : await run(void 0);
     return session ? withProject(result, await naming(session, project)) : result;
   });
   const opened = async (dir) => {
@@ -43001,19 +43422,7 @@ ${LOCAL_PROJECT_GUIDE}`);
       }),
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
     },
-    async ({ url: url2, file_name, project }) => scoped(project, async ({ root }) => {
-      const parsed = new URL(url2);
-      if (parsed.protocol !== "https:") throw new Error("Only https URLs can be imported.");
-      const response = await fetch(parsed);
-      if (!response.ok)
-        throw new Error(`Download failed: ${response.status} ${response.statusText}`);
-      const bytes = Buffer.from(await response.arrayBuffer());
-      const name = (file_name ?? decodeURIComponent(parsed.pathname.split("/").at(-1) ?? "")).replace(/[/\\]/g, "_").replace(/^\.+/, "") || "import";
-      const dir = join9(root, "media");
-      await mkdir5(dir, { recursive: true });
-      const file2 = await newFile(dir, name, (path2) => writeFile5(path2, bytes, { flag: "wx" }));
-      return { src: `./media/${file2}`, bytes: bytes.length };
-    })
+    async ({ url: url2, file_name, project }, ctx) => scoped(project, async ({ origin }) => importMedia(origin, url2, file_name, ctx.mcpReq.signal))
   );
   server.registerTool(
     "video_editing_preview_frames",
@@ -43331,18 +43740,20 @@ function registerPanelRelay(server, store, stateDirectory, direct) {
     server,
     "video_editing_session",
     {
-      description: "Editor: a local project folder (the one `project` names, else the last opened) and the loopback base of the direct route, or why none is open; plus the allowed roots and recent project folders.",
+      description: "Editor: a local project folder (the one `project` names, else the last opened) and the loopback base of the direct route, or why none is open; plus the allowed roots and recent project folders with their names and last activity.",
       inputSchema: { project: sessionArg },
       _meta: appOnly
     },
     async ({ project }) => {
-      const recent = await store.recent();
+      const activity = await store.recentActivity();
+      const recent = activity.map(({ root }) => root);
       const names = Object.fromEntries(
         await Promise.all(
           recent.map(async (path2) => [path2, await projectName(stateDirectory, path2)])
         )
       );
-      const listed = { roots: store.roots(), recent, names };
+      const usedAt = Object.fromEntries(activity.map(({ root, usedAt: usedAt2 }) => [root, usedAt2]));
+      const listed = { roots: store.roots(), recent, names, usedAt };
       try {
         const session = await store.find(project);
         return reply(
@@ -43363,7 +43774,7 @@ function registerPanelRelay(server, store, stateDirectory, direct) {
       _meta: appOnly
     },
     async ({ lines }) => guarded(async () => {
-      await appendFile2(
+      await appendFile(
         join9(stateDirectory, "panel.log"),
         lines.map((line) => `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `).join("")
@@ -43399,13 +43810,17 @@ function registerPanelRelay(server, store, stateDirectory, direct) {
         offset: external_exports.number().int().nonnegative(),
         part: external_exports.string().max(4 << 20),
         last: external_exports.boolean(),
+        cancel: external_exports.boolean().optional(),
         project: sessionArg
       },
       _meta: appOnly
     },
-    async ({ project, ...part }) => guarded(async () => ({
-      ...await uploads.add((await store.session(project)).origin, part)
-    }))
+    async ({ project, ...part }, ctx) => guarded(async () => {
+      const session = await store.session(project);
+      return store.withActivity(session, async () => ({
+        ...await uploads.add(session.origin, part, ctx.mcpReq.signal)
+      }));
+    })
   );
   registerAppTool(
     server,
@@ -43461,7 +43876,7 @@ function registerPanelRelay(server, store, stateDirectory, direct) {
       );
       if (size !== offset) throw new Error(`file ${id2}: expected byte ${size}; start again`);
       const bytes = Buffer.from(part, "base64");
-      await writeFile5(temp, bytes, { flag: offset === 0 ? "w" : "a" });
+      await writeFile6(temp, bytes, { flag: offset === 0 ? "w" : "a" });
       if (!last) return { received: offset + bytes.length };
       const file2 = await newFile(dir, name, (path2) => link3(temp, path2));
       await rm5(temp, { force: true });
@@ -43513,7 +43928,34 @@ var operation = external_exports.discriminatedUnion("op", [
   })
 ]);
 var timelineInputs = {
-  video_editor_read_timeline: external_exports.object({ request_id: id.optional() }),
+  video_editor_read_timeline: external_exports.object({
+    request_id: id.optional(),
+    view: external_exports.enum(["auto", "summary", "clips", "assets"]).optional(),
+    scope: external_exports.enum(["scene", "selection"]).optional(),
+    clip_ids: external_exports.array(id).min(1).max(200).optional(),
+    time_range: external_exports.object({ start: external_exports.number().nonnegative(), end: external_exports.number().positive() }).optional(),
+    offset: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+    limit: external_exports.number().int().min(1).max(100).optional(),
+    expected_revision: id.optional(),
+    text_offset: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional()
+  }).strict().refine((input) => !input.time_range || input.time_range.end > input.time_range.start, {
+    message: "time_range.end must be after time_range.start (timeline seconds)."
+  }).refine(
+    (input) => !((input.offset ?? 0) > 0 || (input.text_offset ?? 0) > 0) || Boolean(input.request_id && input.expected_revision),
+    {
+      message: "Continuation requires the original request_id and expected_revision."
+    }
+  ).refine(
+    (input) => input.text_offset === void 0 || input.view === "clips" && input.clip_ids?.length === 1 && !input.offset,
+    {
+      message: "text_offset requires view=clips, exactly one clip_id, and offset=0."
+    }
+  ).refine(
+    (input) => input.view !== "assets" || input.scope === void 0 && input.clip_ids === void 0 && input.time_range === void 0,
+    {
+      message: "Asset pages do not accept clip scope, IDs or time filters."
+    }
+  ),
   video_editor_apply_timeline: external_exports.object({
     request_id: id,
     expected_revision: id,
@@ -43550,7 +43992,7 @@ var TIMELINE_CHANNEL_META = "higgsfield/timeline-channel";
 
 // src/tools/video-editor-timeline/register.ts
 var descriptions = {
-  video_editor_read_timeline: "Read the live browser Video Editor timeline, captured selection, assets and revision. Use editor_session_id from the editor context attachment. Omit request_id only for a new task; retain the returned request_id through clarifications even when selection changes. No selection is needed for additions. This is not a local disk project. Read before any timeline edit.",
+  video_editor_read_timeline: "Read the live browser Video Editor timeline, captured selection, assets and revision. Use editor_session_id from the editor context attachment. Omit request_id only for a new task; retain it through clarifications even when selection changes. Small default reads contain the full scene; large reads return selected clips or a first scene page. Use view=summary for paged tracks/counts, view=clips for details, scope=scene|selection, clip_ids and time_range to filter. view=assets pages the entire asset library. Continue with next_read plus editor_session_id; keep its request_id, expected_revision, view, scope and filters. offset/limit page entries for that view. Long text has a text_window; continue with view=clips, one clip_id, text_offset and expected_revision. Partial clip previews must not replace whole clips. IDs and absolute indexes remain valid only for the returned revision. Filters do not expand edit permission. No selection is needed for additions. This is not a local disk project. Read before any timeline edit.",
   video_editor_apply_timeline: "Apply native clip, caption, effect or transition changes to the captured browser timeline. Requires editor_session_id, request_id and expected_revision from read_timeline. Use a unique operation_id and reuse it on retry. The editor validates scope, locks and revision, applies one undoable operation and confirms it before success is returned. Never substitute a standalone file or another project.",
   video_editor_attach_result: "Attach a generated video to its source clip in the live browser timeline. Use editor_session_id and request_id from context. Provide the real job_id immediately for progress and automatic placement, or an uploaded HTTPS result_url and stable result_id. range: source preserves trim/speed, clip is an already trimmed result, extend adds duration. Original stays unchanged. Read the timeline to confirm placement after generation finishes."
 };
@@ -44143,7 +44585,7 @@ function createEditorUpdates(options, start = (done) => new Promise((resolve3, r
       }
     }
     return {
-      runningVersion: options?.version ?? "1.0.3" ?? "Source checkout",
+      runningVersion: options?.version ?? "1.0.5" ?? "Source checkout",
       readyVersion: options && selectedDist(options) !== options.dist ? state.active : null,
       channel: options?.channel ?? null,
       supported: options !== null,
@@ -44207,7 +44649,7 @@ var handle = serveStdio(
     const server = new McpServer(
       {
         name: "Higgsfield Video Editor (local)",
-        version: "1.0.3"
+        version: "1.0.5"
       },
       { instructions: VIDEO_EDITOR_LOCAL_INSTRUCTIONS }
     );