deepline 0.3.294 → 0.3.296

package/dist/plays/run-request.mjs

@@ -1,591 +1,33 @@
-// ../plays/tool-execution-error.ts
-var DEEPLINE_ERROR_BRAND = Symbol.for("deepline.error.v1");
-var TOOL_EXECUTION_ERROR_BRAND = Symbol.for(
-  "deepline.tool-execution-error.v1"
-);
-var PROVIDER_TRANSIENT_ERROR_BRAND = Symbol.for(
-  "deepline.provider-transient-error.v1"
-);
-function nativeInstanceOf(constructor, value) {
-  return Reflect.apply(Function.prototype[Symbol.hasInstance], constructor, [
-    value
-  ]);
-}
-function hasBrand(value, brand) {
-  return typeof value === "object" && value !== null && value[brand] === true;
-}
-function applyBrand(value, brand) {
-  if (hasBrand(value, brand)) return;
-  Object.defineProperty(value, brand, {
-    configurable: false,
-    enumerable: false,
-    writable: false,
-    value: true
-  });
-}
-var DeeplineError = class _DeeplineError extends Error {
-  /** HTTP status when the failure crossed an HTTP boundary. */
-  statusCode;
-  /** Stable machine-readable error code when one exists. */
-  code;
-  /** Local diagnostic context; not a portable error contract. */
-  details;
-  /**
-   * Construct a Deepline error.
-   *
-   * SDK and runtime code construct these errors. Application and Play code
-   * normally catches the public subclasses instead.
-   *
-   * @param message Human-readable failure summary.
-   * @param statusCode HTTP status when one exists.
-   * @param code Stable machine-readable code when one exists.
-   * @param details Local diagnostic context; never a portable error contract.
-   */
-  constructor(message, statusCode, code, details) {
-    super(message);
-    this.name = "DeeplineError";
-    this.statusCode = statusCode;
-    this.code = code;
-    this.details = details;
-    applyBrand(this, DEEPLINE_ERROR_BRAND);
-  }
-  static [Symbol.hasInstance](value) {
-    if (this !== _DeeplineError) return nativeInstanceOf(this, value);
-    return hasBrand(value, DEEPLINE_ERROR_BRAND);
-  }
-};
-
-// ../play-runtime/run-lifecycle-policy.ts
-var TERMINAL_PLAY_RUN_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "failed",
-  "cancelled",
-  "terminated",
-  "timed_out"
-]);
-function normalizePlayRunLifecycleStatus(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  switch (normalized) {
-    case "queued":
-    case "pending":
-      return "queued";
-    case "running":
-    case "started":
-      return "running";
-    case "waiting":
-      return "waiting";
-    case "completed":
-    case "complete":
-    case "succeeded":
-      return "completed";
-    case "failed":
-    case "error":
-      return "failed";
-    case "cancelled":
-    case "canceled":
-      return "cancelled";
-    case "terminated":
-      return "terminated";
-    case "timed_out":
-    case "timeout":
-      return "timed_out";
-    default:
-      return "unknown";
-  }
-}
-function isTerminalPlayRunLifecycleStatus(status) {
-  return TERMINAL_PLAY_RUN_STATUSES.has(
-    normalizePlayRunLifecycleStatus(status)
-  );
-}
-
-// src/api-error.ts
-function asRecord(value) {
-  return typeof value === "object" && value !== null ? value : null;
-}
-function apiErrorCodeFromResponse(parsed) {
-  const response = asRecord(parsed);
-  const error = asRecord(response?.error);
-  const code = error?.code ?? response?.code;
-  return typeof code === "string" ? code : "API_ERROR";
-}
-function apiErrorMessage(parsed, status) {
-  const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
-  if (typeof errorValue === "string") {
-    return errorValue;
-  }
-  if (errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string") {
-    return errorValue.message;
-  }
-  if (typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string") {
-    return parsed.message;
-  }
-  return `HTTP ${status}`;
-}
-
-// src/plays/run-request.ts
-var PLAY_RUN_START_PATH = "/api/v2/plays/run";
-var PLAY_RUN_START_STREAM_PATH = `${PLAY_RUN_START_PATH}?stream=true`;
-var PLAY_FILES_STAGE_PATH = "/api/v2/plays/files/stage";
-var PLAY_FILES_STAGE_MINT_PATH = `${PLAY_FILES_STAGE_PATH}/mint`;
-function buildPlayRunStartBody(request) {
-  return {
-    ...request.name ? { name: request.name } : {},
-    ...request.revisionId ? { revisionId: request.revisionId } : {},
-    ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
-    ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
-    ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
-    ...request.description ? { description: request.description } : {},
-    ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
-    ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
-    ...request.graphHash ? { graphHash: request.graphHash } : {},
-    ...request.runtimeArtifact ? { runtimeArtifact: request.runtimeArtifact } : {},
-    ...request.compilerManifest ? { compilerManifest: request.compilerManifest } : {},
-    ...request.inputFileUpload ? { inputFileUpload: request.inputFileUpload } : {},
-    ...request.packagedFileUploads?.length ? { packagedFileUploads: request.packagedFileUploads } : {},
-    ...request.input ? { input: request.input } : {},
-    ...request.inputFile ? { inputFile: request.inputFile } : {},
-    ...request.packagedFiles?.length ? { packagedFiles: request.packagedFiles } : {},
-    ...request.force ? { force: true } : {},
-    ...request.forceToolRefresh === true ? { forceToolRefresh: true } : {},
-    ...typeof request.maxConcurrentExternalCalls === "number" ? { maxConcurrentExternalCalls: request.maxConcurrentExternalCalls } : {},
-    ...typeof request.maxConcurrentRows === "number" ? { maxConcurrentRows: request.maxConcurrentRows } : {},
-    ...typeof request.waitForCompletionMs === "number" ? { waitForCompletionMs: request.waitForCompletionMs } : {},
-    // Profile selection is the API's job, not the caller's. The server
-    // defaults to absurd; callers normally omit this field.
-    ...request.profile ? { profile: request.profile } : {},
-    ...request.integrationMode ? { integrationMode: request.integrationMode } : {},
-    ...request.fixtureBehavior ? { fixtureBehavior: request.fixtureBehavior } : {},
-    ...request.runtime ? { runtime: request.runtime } : {},
-    ...request.testPolicyOverrides ? { testPolicyOverrides: request.testPolicyOverrides } : {}
-  };
-}
-async function startPlayRun(http, request, headers) {
-  const response = await http.post(
-    PLAY_RUN_START_PATH,
-    buildPlayRunStartBody(request),
-    headers,
-    { maxRetries: 0, exactUrlOnly: true }
-  );
-  return normalizePlayRunStart(response);
-}
-function isPlayRunPackage(value) {
-  return Boolean(
-    value && typeof value === "object" && !Array.isArray(value) && value.kind === "play_run" && value.run && typeof value.run?.id === "string"
-  );
-}
-function normalizePlayRunStart(raw) {
-  const runPackage = isPlayRunPackage(raw) ? raw : isPlayRunPackage(raw.package) ? raw.package : null;
-  if (!runPackage) {
-    const workflowId = typeof raw.workflowId === "string" && raw.workflowId ? raw.workflowId : typeof raw.runId === "string" ? raw.runId : "";
-    return {
-      ...raw,
-      workflowId
-    };
-  }
-  const status = typeof runPackage.run.status === "string" ? runPackage.run.status : "running";
-  return {
-    workflowId: runPackage.run.id,
-    name: runPackage.run.playName,
-    status,
-    ...runPackage.run.dashboardUrl ? { dashboardUrl: runPackage.run.dashboardUrl } : {},
-    ...isTerminalPlayRunLifecycleStatus(status) ? { finalStatus: runPackage } : {},
-    package: runPackage
-  };
-}
-function buildNamedPlayRunRequest(input) {
-  return {
-    name: input.name,
-    ...input.revisionId ? { revisionId: input.revisionId } : {},
-    ...Object.keys(input.runtimeInput).length > 0 ? { input: input.runtimeInput } : {},
-    ...input.stagedFileInputs.inputFile ? { inputFile: input.stagedFileInputs.inputFile } : {},
-    ...input.stagedFileInputs.packagedFiles.length ? { packagedFiles: input.stagedFileInputs.packagedFiles } : {},
-    ...input.extra
-  };
-}
-var CSV_DATA_INPUT_KEY = "csv";
-function schemaMetadata(schema, key) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema))
-    return null;
-  const value = schema[key];
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function stringMetadata(metadata, key) {
-  const value = metadata?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function inputFieldFromCsvArg(csvArg) {
-  if (typeof csvArg !== "string") return null;
-  const match = /^\(?\s*input\.([A-Za-z_$][\w$]*)\s*\)?(?:\s*\?\?[\s\S]+)?$/.exec(
-    csvArg.trim()
-  );
-  return match?.[1] ?? null;
-}
-function fileInputBindingsFromPlaySchema(inputSchema) {
-  const csvInput = schemaMetadata(inputSchema, "csvInput");
-  if (!csvInput) return [];
-  return [
-    {
-      inputPath: stringMetadata(csvInput, "inputField") ?? CSV_DATA_INPUT_KEY
-    }
-  ];
-}
-function fileInputBindingsFromStaticPipeline(staticPipeline) {
-  if (!staticPipeline || typeof staticPipeline !== "object" || Array.isArray(staticPipeline)) {
-    return [];
-  }
-  const inputField = inputFieldFromCsvArg(
-    staticPipeline.csvArg
-  );
-  return inputField ? [{ inputPath: inputField }] : [];
-}
-function playRunFileInputBindings(play) {
-  return [
-    ...fileInputBindingsFromPlaySchema(play.inputSchema),
-    ...fileInputBindingsFromStaticPipeline(play.staticPipeline)
-  ];
-}
-function getDottedInputValue(input, path) {
-  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
-  let cursor = input;
-  for (const part of parts) {
-    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
-      return void 0;
-    }
-    cursor = cursor[part];
-  }
-  return cursor;
-}
-function setDottedInputValue(input, path, value) {
-  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
-  if (parts.length === 0) {
-    throw new Error(`Invalid play input flag path: ${path}`);
-  }
-  let cursor = input;
-  for (const part of parts.slice(0, -1)) {
-    const existing = cursor[part];
-    if (existing !== void 0 && (!existing || typeof existing !== "object" || Array.isArray(existing))) {
-      throw new Error(
-        `Cannot set --${path}; input.${part} is already a non-object value.`
-      );
-    }
-    if (!existing) {
-      cursor[part] = {};
-    }
-    cursor = cursor[part];
-  }
-  cursor[parts[parts.length - 1]] = value;
-}
-var webStagedFileCodec = {
-  async sha256Hex(bytes) {
-    const digest = await globalThis.crypto.subtle.digest(
-      "SHA-256",
-      bytes
-    );
-    return Array.from(
-      new Uint8Array(digest),
-      (byte) => byte.toString(16).padStart(2, "0")
-    ).join("");
-  },
-  base64(bytes) {
-    let binary = "";
-    for (let offset = 0; offset < bytes.length; offset += 32768) {
-      binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
-    }
-    return btoa(binary);
-  }
-};
-function stagedFileContentType(logicalPath) {
-  const lower = logicalPath.toLowerCase();
-  return lower.endsWith(".csv") ? "text/csv" : lower.endsWith(".json") ? "application/json" : "application/octet-stream";
-}
-async function createStagedFileUpload(logicalPath, bytes, codec = webStagedFileCodec) {
-  return {
-    logicalPath,
-    contentBase64: codec.base64(bytes),
-    contentHash: await codec.sha256Hex(bytes),
-    contentType: stagedFileContentType(logicalPath),
-    bytes: bytes.byteLength
-  };
-}
-var STAGE_LEGACY_MULTIPART_MAX_BYTES = 4e6;
-var STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS = 3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function stagedUploadIdentity(logicalPath, contentHash) {
-  return `${contentHash}:${logicalPath}`;
-}
-function isStagedUploadMintUnsupported(error) {
-  return error instanceof DeeplineError && error.statusCode === 404;
-}
-function isStagedUploadDirectEgressDenied(error) {
-  return error instanceof DeeplineError && error.code === "STAGED_FILE_UPLOAD_EGRESS_DENIED";
-}
-function formatMegabytes(bytes) {
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-function decodeBase64Bytes(value) {
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index);
-  }
-  return bytes;
-}
-async function uploadStagedFileToPresignedUrl(input) {
-  const arrayBuffer = input.body.buffer.slice(
-    input.body.byteOffset,
-    input.body.byteOffset + input.body.byteLength
-  );
-  let lastError;
-  for (let attempt = 1; attempt <= STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS; attempt += 1) {
-    try {
-      const response = await fetch(input.url, {
-        method: "PUT",
-        headers: input.headers,
-        body: new Blob([arrayBuffer])
-      });
-      if (response.ok) {
-        return;
-      }
-      const text = await response.text().catch(() => "");
-      const egressDenied = response.status === 403 && response.headers.get("x-deny-reason")?.trim().toLowerCase() === "host_not_allowed";
-      lastError = new DeeplineError(
-        `Direct storage upload of ${input.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
-        response.status,
-        egressDenied ? "STAGED_FILE_UPLOAD_EGRESS_DENIED" : "STAGED_FILE_UPLOAD_FAILED",
-        { logicalPath: input.logicalPath }
-      );
-      if (response.status < 500 && response.status !== 429) {
-        break;
-      }
-    } catch (error) {
-      lastError = error instanceof TypeError ? new DeeplineError(
-        `Direct storage upload of ${input.logicalPath} could not reach the storage endpoint: ${error.message}`,
-        void 0,
-        "STAGED_FILE_UPLOAD_EGRESS_DENIED",
-        { logicalPath: input.logicalPath }
-      ) : error;
-    }
-    if (attempt < STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS) {
-      await sleep(250 * attempt);
-    }
-  }
-  throw lastError instanceof Error ? lastError : new DeeplineError(
-    `Direct storage upload of ${input.logicalPath} failed.`,
-    void 0,
-    "STAGED_FILE_UPLOAD_FAILED",
-    { logicalPath: input.logicalPath }
-  );
-}
-async function mintStagedPlayFileUploads(http, files) {
-  const response = await http.post(PLAY_FILES_STAGE_MINT_PATH, { files });
-  return response.uploads ?? [];
-}
-async function stagePlayFilesViaMultipart(http, files, reason = "mint-unsupported") {
-  for (const file of files) {
-    if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
-      const reasonMessage = reason === "direct-egress-denied" ? "direct storage is blocked by this environment's network egress policy" : "the connected Deepline server does not support direct-to-storage uploads";
-      throw new DeeplineError(
-        `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): ${reasonMessage}, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to.`,
-        413,
-        "STAGED_FILE_TOO_LARGE_FOR_LEGACY_UPLOAD",
-        {
-          logicalPath: file.logicalPath,
-          bytes: file.bytes,
-          maxBytes: STAGE_LEGACY_MULTIPART_MAX_BYTES
-        }
-      );
-    }
-  }
-  const buildFormData = () => {
-    const formData = new FormData();
-    formData.set(
-      "metadata",
-      JSON.stringify({
-        files: files.map((file, index) => ({
-          index,
-          logicalPath: file.logicalPath,
-          contentHash: file.contentHash,
-          contentType: file.contentType,
-          bytes: file.bytes
-        }))
-      })
-    );
-    for (const [index, file] of files.entries()) {
-      const bytes = decodeBase64Bytes(file.contentBase64);
-      const body = bytes.buffer.slice(
-        bytes.byteOffset,
-        bytes.byteOffset + bytes.byteLength
-      );
-      formData.set(
-        `file:${index}`,
-        new Blob([body], { type: file.contentType }),
-        file.logicalPath
-      );
-    }
-    return formData;
-  };
-  const response = await http.postFormData(PLAY_FILES_STAGE_PATH, buildFormData);
-  return response.files;
-}
-async function stagePlayFiles(http, files) {
-  let uploads;
-  try {
-    uploads = await mintStagedPlayFileUploads(
-      http,
-      files.map((file) => ({
-        logicalPath: file.logicalPath,
-        contentHash: file.contentHash,
-        contentType: file.contentType,
-        bytes: file.bytes
-      }))
-    );
-  } catch (error) {
-    if (isStagedUploadMintUnsupported(error)) {
-      return stagePlayFilesViaMultipart(http, files);
-    }
-    throw error;
-  }
-  const uploadByIdentity = /* @__PURE__ */ new Map();
-  for (const upload of uploads) {
-    uploadByIdentity.set(
-      stagedUploadIdentity(upload.logicalPath, upload.contentHash),
-      upload
-    );
-  }
-  const directResults = await Promise.all(
-    files.map(async (file) => {
-      const upload = uploadByIdentity.get(
-        stagedUploadIdentity(file.logicalPath, file.contentHash)
-      );
-      if (!upload) {
-        throw new DeeplineError(
-          `The staging server did not return an upload target for ${file.logicalPath}.`,
-          void 0,
-          "STAGED_FILE_MINT_INCOMPLETE"
-        );
-      }
-      if (upload.alreadyStaged || !upload.uploadUrl) {
-        return { ref: upload.ref };
-      }
-      try {
-        await uploadStagedFileToPresignedUrl({
-          url: upload.uploadUrl,
-          headers: upload.uploadHeaders ?? {
-            "content-type": file.contentType
-          },
-          body: decodeBase64Bytes(file.contentBase64),
-          logicalPath: file.logicalPath
-        });
-        return { ref: upload.ref };
-      } catch (error) {
-        if (isStagedUploadDirectEgressDenied(error)) {
-          return { fallbackFile: file };
-        }
-        throw error;
-      }
-    })
-  );
-  return await Promise.all(
-    directResults.map(async (result) => {
-      if ("fallbackFile" in result) {
-        const [ref] = await stagePlayFilesViaMultipart(
-          http,
-          [result.fallbackFile],
-          "direct-egress-denied"
-        );
-        if (!ref) {
-          throw new DeeplineError(
-            `The staging server did not return an upload target for ${result.fallbackFile.logicalPath}.`,
-            void 0,
-            "STAGED_FILE_MINT_INCOMPLETE"
-          );
-        }
-        return ref;
-      }
-      return result.ref;
-    })
-  );
-}
-async function stageFileInputs(input) {
-  const uniqueBindings = [
-    ...new Map(
-      input.bindings.map((binding) => [binding.inputPath, binding])
-    ).values()
-  ];
-  const localFiles = uniqueBindings.flatMap((binding) => {
-    const file = input.resolveLocalFile(
-      getDottedInputValue(input.runtimeInput, binding.inputPath),
-      binding
-    );
-    return file ? [{ binding, file }] : [];
-  });
-  if (localFiles.length === 0) {
-    return { inputFile: null, packagedFiles: [] };
-  }
-  input.onStaging?.(localFiles.length);
-  const uploads = await Promise.all(
-    localFiles.map(
-      async ({ file }) => createStagedFileUpload(file.logicalPath, await file.read(), input.codec)
-    )
-  );
-  const staged = await input.stage(uploads);
-  for (const [index, { binding, file }] of localFiles.entries()) {
-    setDottedInputValue(
-      input.runtimeInput,
-      binding.inputPath,
-      file.logicalPath
-    );
-    const stagedFile = staged[index];
-    if (stagedFile && stagedFile.logicalPath !== file.logicalPath) {
-      setDottedInputValue(
-        input.runtimeInput,
-        binding.inputPath,
-        stagedFile.logicalPath
-      );
-    }
-  }
-  return {
-    inputFile: staged[0] ?? null,
-    packagedFiles: staged.slice(1)
-  };
-}
-function createSessionPlayRunHttp(fetchImpl = (...args) => fetch(...args)) {
-  const send = async (path, init) => {
-    const response = await fetchImpl(path, {
-      ...init,
-      credentials: "include"
-    });
-    const text = await response.text();
-    let parsed = text;
-    try {
-      parsed = text ? JSON.parse(text) : null;
-    } catch {
-    }
-    if (!response.ok) {
-      throw new DeeplineError(
-        apiErrorMessage(parsed, response.status),
-        response.status,
-        apiErrorCodeFromResponse(parsed),
-        { response: parsed }
-      );
-    }
-    return parsed;
-  };
-  return {
-    post: (path, body, headers) => send(path, {
-      method: "POST",
-      headers: { "content-type": "application/json", ...headers },
-      body: JSON.stringify(body)
-    }),
-    postFormData: (path, formData) => send(path, {
-      method: "POST",
-      body: typeof formData === "function" ? formData() : formData
-    })
-  };
-}
+import {
+  CSV_DATA_INPUT_KEY,
+  PLAY_FILES_STAGE_MINT_PATH,
+  PLAY_FILES_STAGE_PATH,
+  PLAY_RUN_START_PATH,
+  PLAY_RUN_START_STREAM_PATH,
+  STAGE_LEGACY_MULTIPART_MAX_BYTES,
+  buildNamedPlayRunRequest,
+  buildPlayRunStartBody,
+  createSessionPlayRunHttp,
+  createStagedFileUpload,
+  fileInputBindingsFromPlaySchema,
+  fileInputBindingsFromStaticPipeline,
+  getDottedInputValue,
+  isPlayRunPackage,
+  mintStagedPlayFileUploads,
+  normalizePlayRunStart,
+  playRunFileInputBindings,
+  setDottedInputValue,
+  stageFileInputs,
+  stagePlayFiles,
+  stagedFileContentType,
+  startPlayRun,
+  webStagedFileCodec
+} from "../cli/chunk-CBVIJSHF.mjs";
+import "../cli/chunk-DLIRSHV6.mjs";
+import {
+  DeeplineError
+} from "../cli/chunk-NXGCO4JB.mjs";
+import "../cli/chunk-KRD6H754.mjs";
 export {
   CSV_DATA_INPUT_KEY,
   DeeplineError,

package/dist/release.d.mts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.294";
+    readonly version: "0.3.296";
     readonly updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.d.ts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.294";
+    readonly version: "0.3.296";
     readonly updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;