@uniformdev/automations-sdk 20.50.2-alpha.109

package/dist/api/index.mjs

@@ -0,0 +1,102 @@
+import {
+  formatAutomationWebhookUrl
+} from "../chunk-TWKWPWN3.mjs";
+import {
+  __privateAdd,
+  __privateGet
+} from "../chunk-I6KKUHEY.mjs";
+
+// src/api/AutomationsClient.ts
+import { ApiClient } from "@uniformdev/context/api";
+var _automationsUrl, _runsUrl, _logsUrl;
+var _AutomationsClient = class _AutomationsClient extends ApiClient {
+  /**
+   * Lists the automations configured for a project.
+   */
+  async list() {
+    const { projectId } = this.options;
+    return await this.apiClient(
+      this.createUrl(__privateGet(_AutomationsClient, _automationsUrl), { projectId })
+    );
+  }
+  /**
+   * Deploys (creates or updates) a single automation.
+   *
+   * @param input - The automation definition + bundled code.
+   */
+  async deploy(input) {
+    const { projectId } = this.options;
+    await this.apiClient(this.createUrl(__privateGet(_AutomationsClient, _automationsUrl)), {
+      method: "PUT",
+      body: JSON.stringify({ ...input, projectId }),
+      expectNoContent: true
+    });
+  }
+  /**
+   * Toggles the enabled state of an automation.
+   *
+   * @param publicId - The automation public ID.
+   * @param enabled - The desired enabled state.
+   */
+  async setEnabled(publicId, enabled) {
+    const { projectId } = this.options;
+    await this.apiClient(this.createUrl(__privateGet(_AutomationsClient, _automationsUrl)), {
+      method: "PATCH",
+      body: JSON.stringify({ projectId, publicId, enabled }),
+      expectNoContent: true
+    });
+  }
+  /**
+   * Deletes an automation.
+   *
+   * @param publicId - The automation public ID.
+   */
+  async remove(publicId) {
+    const { projectId } = this.options;
+    await this.apiClient(this.createUrl(__privateGet(_AutomationsClient, _automationsUrl)), {
+      method: "DELETE",
+      body: JSON.stringify({ projectId, publicId }),
+      expectNoContent: true
+    });
+  }
+  /**
+   * Lists automation runs for the project, optionally filtered by automation and status.
+   */
+  async listRuns(options) {
+    var _a;
+    const { projectId } = this.options;
+    const status = ((_a = options == null ? void 0 : options.statuses) == null ? void 0 : _a.length) ? options.statuses.join(",") : void 0;
+    return await this.apiClient(
+      this.createUrl(__privateGet(_AutomationsClient, _runsUrl), {
+        projectId,
+        publicId: options == null ? void 0 : options.publicId,
+        status,
+        offset: options == null ? void 0 : options.offset,
+        limit: options == null ? void 0 : options.limit
+      })
+    );
+  }
+  /**
+   * Returns the log entries for a single automation run.
+   *
+   * @param runId - The automation run ID.
+   */
+  async listRunLogs(runId) {
+    const { projectId } = this.options;
+    const { logs } = await this.apiClient(
+      this.createUrl(__privateGet(_AutomationsClient, _logsUrl), { projectId, runId })
+    );
+    return logs;
+  }
+};
+_automationsUrl = new WeakMap();
+_runsUrl = new WeakMap();
+_logsUrl = new WeakMap();
+__privateAdd(_AutomationsClient, _automationsUrl, "/api/v1/automations");
+__privateAdd(_AutomationsClient, _runsUrl, "/api/v1/automation-runs");
+__privateAdd(_AutomationsClient, _logsUrl, "/api/v1/automation-run-logs");
+var AutomationsClient = _AutomationsClient;
+export {
+  AutomationsClient,
+  formatAutomationWebhookUrl
+};

package/dist/chunk-I6KKUHEY.mjs

@@ -0,0 +1,15 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod
+};

package/dist/chunk-TWKWPWN3.mjs

@@ -0,0 +1,10 @@
+// src/formatAutomationWebhookUrl.ts
+function formatAutomationWebhookUrl(apiHost, projectId, publicId) {
+  const base = apiHost.replace(/\/$/, "");
+  const params = new URLSearchParams({ projectId, publicId });
+  return `${base}/api/v1/automation-webhooks?${params.toString()}`;
+}
+
+export {
+  formatAutomationWebhookUrl
+};

package/dist/formatAutomationWebhookUrl-CD1HQmu6.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Builds the public URL external systems POST to for an incoming-webhook automation.
+ *
+ * @param apiHost - Uniform API host (e.g. `https://uniform.app` or `window.location.origin`).
+ * @param projectId - The project ID.
+ * @param publicId - The automation public ID.
+ */
+declare function formatAutomationWebhookUrl(apiHost: string, projectId: string, publicId: string): string;
+
+export { formatAutomationWebhookUrl as f };

package/dist/index.d.mts

@@ -0,0 +1,272 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { WebhookEventName, WebhookPayloadFor } from '@uniformdev/webhooks';
+import { AutomationResult, AutomationLogEntry } from './schemas/index.mjs';
+export { f as formatAutomationWebhookUrl } from './formatAutomationWebhookUrl-CD1HQmu6.mjs';
+import 'zod';
+
+/**
+ * Trigger configuration for a Uniform platform webhook event. The discriminator
+ * `type` is the event name itself (e.g. `entry.changed`), drawn from the
+ * `@uniformdev/webhooks` catalog.
+ */
+type EventTriggerConfig<TEvent extends WebhookEventName = WebhookEventName> = {
+    type: TEvent;
+};
+/** Trigger configuration for a schedule automation. */
+type ScheduleTriggerConfig = {
+    type: 'schedule';
+    /** RFC-5545 recurrence rule for when the automation runs. */
+    rrule: string;
+    /** IANA timezone used to evaluate the recurrence rule. */
+    timezone: string;
+};
+/** Trigger configuration for an incoming webhook automation. */
+type IncomingWebhookTriggerConfig = {
+    type: 'incomingWebhook';
+};
+/** Trigger configuration for an automation invocable as an AI tool by Scout. */
+type AiToolTriggerConfig = {
+    type: 'aiTool';
+};
+/** Canonical authored trigger configuration. */
+type TriggerConfig = EventTriggerConfig | ScheduleTriggerConfig | IncomingWebhookTriggerConfig | AiToolTriggerConfig;
+/** A plain JSON Schema object (used when the argument contract is authored as JSON Schema directly). */
+type JsonSchemaObject = Record<string, unknown>;
+/**
+ * The argument contract for an AI-tool automation, surfaced to the LLM.
+ *
+ * Authored as either a zod schema or a JSON Schema object passed through verbatim.
+ * Note: non-zod standard schema providers are not supported.
+ */
+type AiToolInputSchema = StandardSchemaV1 | JsonSchemaObject;
+/**
+ * Role grants for the automation's identity.
+ */
+type AutomationPermissions = {
+    /** Role grant(s), by team role public ID, on the automation's home project. */
+    role: string | string[];
+    /** Additional project role grants (use only when you need to give permissions to other projects within the same team). */
+    projects?: Record<string, string | string[]>;
+};
+type AutomationMetadataBase = {
+    /** Display name surfaced in the dashboard and run history. */
+    name: string;
+    description?: string;
+    /** Runtime compatibility date override (YYYY-MM-DD). */
+    compatibilityDate?: string;
+    /**
+     * Role grants for the automation's identity. When omitted, the automation runs without
+     * Uniform API access.
+     */
+    permissions?: AutomationPermissions;
+};
+/**
+ * Authored metadata for an event-triggered automation. Parameterize `TEvent`
+ * with a webhook event name; {@link defineAutomation} then infers the handler's
+ * `trigger` and `input` from the metadata.
+ */
+type EventAutomationMetadata<TEvent extends WebhookEventName = WebhookEventName> = AutomationMetadataBase & {
+    trigger: EventTriggerConfig<TEvent>;
+};
+/** Authored metadata for a schedule-triggered automation. */
+type ScheduleAutomationMetadata = AutomationMetadataBase & {
+    trigger: ScheduleTriggerConfig;
+};
+/** Authored metadata for an incoming-webhook automation. */
+type IncomingWebhookAutomationMetadata = AutomationMetadataBase & {
+    trigger: IncomingWebhookTriggerConfig;
+};
+/**
+ * Authored metadata for an automation exposed as an AI tool to Scout.
+ *
+ * `description` is required (it drives tool selection by the LLM) and `inputSchema`
+ * declares the tool's argument contract. When `inputSchema` is a zod schema,
+ * {@link defineAutomation} infers the handler's `input` from it.
+ */
+type AiToolAutomationMetadata = AutomationMetadataBase & {
+    /** Required for AI tools — the LLM uses it to decide when to call the automation. */
+    description: string;
+    trigger: AiToolTriggerConfig;
+    /**
+     * Argument contract surfaced to the LLM. A zod schema or a JSON Schema object.
+     */
+    inputSchema: AiToolInputSchema;
+};
+/** Authored metadata declared via {@link defineAutomation}. */
+type AutomationMetadata = EventAutomationMetadata | ScheduleAutomationMetadata | IncomingWebhookAutomationMetadata | AiToolAutomationMetadata;
+
+/**
+ * Per-run Uniform API connection parameters.
+ *
+ * @example
+ * ```ts
+ * import { CanvasClient } from '@uniformdev/canvas';
+ *
+ * if(!context.uniformCredentials) {
+ *   throw new Error('The automation does not have credentials assigned.');
+ * }
+ *
+ * const canvas = new CanvasClient(context.uniformCredentials);
+ * await canvas.updateComposition({ ... });
+ * ```
+ */
+interface UniformConnectionParams {
+    /**
+     * Per-run bearer token for the connection's identity. Present for machine-identity
+     * runs (event/schedule/webhook) and for AI-tool runs where the invoking caller used
+     * a bearer token.
+     */
+    bearerToken?: string;
+    /**
+     * Per-run API key for the connection's identity. Present for AI-tool runs where the
+     * invoking caller authenticated with an `x-api-key` rather than a bearer token.
+     */
+    apiKey?: string;
+    /** The Uniform project the automation is deployed to. */
+    projectId: string;
+    /** Uniform API host (e.g. `https://uniform.app`). */
+    apiHost?: string;
+    /** Uniform edge API host (e.g. `https://uniform.global`). */
+    edgeApiHost?: string;
+    /** Uniform AI API host where Scout runs (e.g. `https://ai.uniform.global`). */
+    aiApiHost?: string;
+}
+
+/** Severity levels for structured automation logs. */
+type AutomationLogLevel = 'info' | 'warning' | 'error';
+/**
+ * Structured logger available to automation code; entries appear in the run log.
+ * Note: for AI tool triggers, the logger defines the context added to the calling LLM.
+ */
+interface AutomationLogger {
+    /** Records an informational log entry. */
+    info(message: string): void;
+    /** Records a warning log entry. */
+    warning(message: string): void;
+    /** Records an error log entry. */
+    error(message: string): void;
+}
+/**
+ * Authoring context passed to an automation handler.
+ *
+ * The shape is intentionally minimal (`{ trigger, input, log }`) and stable so
+ * future SDK versions can add capabilities without breaking already-authored
+ * functions — do not rely on the absence of other properties.
+ *
+ * @typeParam TInput - The run input type
+ * @typeParam TTrigger - The authored trigger configuration.
+ */
+interface AutomationContext<TInput = unknown, TTrigger extends TriggerConfig = TriggerConfig> {
+    /** The automation's trigger definition. */
+    trigger: TTrigger;
+    /** The input payload for this run (event payload, incoming webhook request, or none for schedule). */
+    input: TInput;
+    /** Structured logger; entries appear in the run log. */
+    log: AutomationLogger;
+    /**
+     * Per-run credentials for Uniform API clients. Present when the automation has an
+     * assigned role (event/schedule/webhook) or, for the `aiTool` trigger, carrying the
+     * invoking caller's own credential so the run acts as that user.
+     */
+    uniformCredentials?: UniformConnectionParams;
+}
+/**
+ * Handler function passed to {@link defineAutomation}.
+ *
+ * Return an {@link AutomationResult} to record the run's outcome, or
+ * return void to signal implicit success. Unhandled exceptions signal implicit failure.
+ *
+ * @typeParam TInput - The input payload type.
+ * @typeParam TTrigger - The trigger configuration.
+ */
+type AutomationHandler<TInput = unknown, TTrigger extends TriggerConfig = TriggerConfig> = (context: AutomationContext<TInput, TTrigger>) => Promise<AutomationResult | void> | AutomationResult | void;
+
+/** HTTP request details passed to an incoming-webhook automation handler. */
+type IncomingWebhookInput = {
+    /** HTTP method of the incoming request (e.g. `POST`). */
+    method: string;
+    /** Normalized request headers (lower-cased keys). */
+    headers: Record<string, string>;
+    /** Parsed query-string parameters. */
+    query: Record<string, string>;
+    /** Raw request body as received (UTF-8 string). */
+    rawBody: string;
+};
+
+/**
+ * Payload Uniform passes when invoking a deployed automation's default export.
+ * {@link defineAutomation} wraps a handler to accept this shape.
+ */
+interface AutomationInvokePayload {
+    /** The automation's declared trigger configuration. */
+    trigger: TriggerConfig;
+    /** Input for this run. */
+    input: unknown;
+    /**
+     * Per-run Uniform API credentials. Present when the automation has an assigned role,
+     * or for the `aiTool` trigger (credentials of the caller).
+     */
+    uniformCredentials?: UniformConnectionParams;
+}
+
+/**
+ * Callable shape of a default-exported automation module. Uniform invokes it with
+ * {@link AutomationInvokePayload}; use {@link defineAutomation} rather than
+ * implementing this directly.
+ */
+type AutomationInvoker = (payload: AutomationInvokePayload) => Promise<AutomationResult & {
+    logs: AutomationLogEntry[];
+}>;
+/**
+ * Resolves the handler input type from authored metadata: AI-tool arguments (from
+ * the declared `inputSchema`), event payload, incoming-webhook request details, or
+ * `unknown` for schedule triggers.
+ */
+type InputFromAutomationMetadata<M extends AutomationMetadata> = M extends {
+    trigger: {
+        type: 'aiTool';
+    };
+    inputSchema: infer S;
+} ? S extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<S> : unknown : M extends {
+    trigger: infer TTrigger;
+} ? TTrigger extends {
+    type: infer TType;
+} ? TType extends WebhookEventName ? WebhookPayloadFor<TType> : TType extends 'incomingWebhook' ? IncomingWebhookInput : unknown : unknown : unknown;
+/**
+ * Resolves the handler trigger type from authored metadata (the literal
+ * `metadata.trigger` object).
+ */
+type TriggerFromAutomationMetadata<M extends AutomationMetadata> = M extends {
+    trigger: infer TTrigger;
+} ? TTrigger : TriggerConfig;
+/** A fully defined automation module: a callable invoke function with authored metadata attached. */
+type AutomationDefinition<M extends AutomationMetadata = AutomationMetadata> = AutomationInvoker & {
+    metadata: M;
+};
+/**
+ * Defines an automation from authored metadata and a handler. Default-export the
+ * return value from the module:
+ *
+ * ```ts
+ * import { defineAutomation } from '@uniformdev/automations-sdk';
+ *
+ * export default defineAutomation({
+ *   metadata: {
+ *     name: 'On entry save',
+ *     trigger: { type: 'entry.changed' },
+ *   },
+ *   handler: async ({ trigger, input, log }) => {
+ *     // trigger.type is 'entry.changed'; input is that event's payload
+ *   },
+ * });
+ * ```
+ *
+ * @param config - Authored metadata and handler implementation.
+ * @returns A callable default export with a `metadata` property.
+ */
+declare function defineAutomation<const M extends AutomationMetadata>(config: {
+    metadata: M;
+    handler: AutomationHandler<InputFromAutomationMetadata<M>, TriggerFromAutomationMetadata<M>>;
+}): AutomationDefinition<M>;
+
+export { type AiToolAutomationMetadata, type AiToolInputSchema, type AiToolTriggerConfig, type AutomationContext, type AutomationDefinition, type AutomationHandler, type AutomationInvokePayload, type AutomationInvoker, AutomationLogEntry, type AutomationLogLevel, type AutomationLogger, type AutomationMetadata, type AutomationPermissions, AutomationResult, type EventAutomationMetadata, type EventTriggerConfig, type IncomingWebhookAutomationMetadata, type IncomingWebhookInput, type IncomingWebhookTriggerConfig, type InputFromAutomationMetadata, type JsonSchemaObject, type ScheduleAutomationMetadata, type ScheduleTriggerConfig, type TriggerConfig, type TriggerFromAutomationMetadata, type UniformConnectionParams, defineAutomation };

package/dist/index.mjs

@@ -0,0 +1,55 @@
+import {
+  formatAutomationWebhookUrl
+} from "./chunk-TWKWPWN3.mjs";
+import "./chunk-I6KKUHEY.mjs";
+
+// src/runtime.ts
+function captureLog(logs, level, message) {
+  logs.push({ level, message, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+  switch (level) {
+    case "info":
+      console.info(message);
+      break;
+    case "warning":
+      console.warn(message);
+      break;
+    case "error":
+      console.error(message);
+      break;
+  }
+}
+async function runAutomationHandler(handler, payload) {
+  var _a, _b;
+  const logs = [];
+  const log = {
+    info: (message) => captureLog(logs, "info", message),
+    warning: (message) => captureLog(logs, "warning", message),
+    error: (message) => captureLog(logs, "error", message)
+  };
+  const context = {
+    trigger: payload.trigger,
+    input: payload.input,
+    log
+  };
+  if (payload.uniformCredentials) {
+    context.uniformCredentials = payload.uniformCredentials;
+  }
+  try {
+    const result = await handler(context);
+    return { outcome: (_a = result == null ? void 0 : result.outcome) != null ? _a : "success", logs };
+  } catch (e) {
+    const message = e instanceof Error ? (_b = e.stack) != null ? _b : e.message : String(e);
+    captureLog(logs, "error", message);
+    return { outcome: "failure", logs };
+  }
+}
+
+// src/defineAutomation.ts
+function defineAutomation(config) {
+  const invoker = (payload) => runAutomationHandler(config.handler, payload);
+  return Object.assign(invoker, { metadata: config.metadata });
+}
+export {
+  defineAutomation,
+  formatAutomationWebhookUrl
+};

package/dist/schemas/index.d.mts

@@ -0,0 +1,64 @@
+import * as z from 'zod';
+
+/**
+ * Zod schema for a structured automation log entry. Import from
+ * `@uniformdev/automations-sdk/schemas` when validating run logs.
+ */
+declare const automationLogEntrySchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        error: "error";
+    }>;
+    message: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A single structured log entry captured during a run. Authored automation code
+ * produces these via the run `log`; they appear in the run log.
+ */
+type AutomationLogEntry = z.infer<typeof automationLogEntrySchema>;
+/**
+ * Zod schema for an automation handler result. Import from
+ * `@uniformdev/automations-sdk/schemas` when validating handler outcomes.
+ */
+declare const automationResultSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        success: "success";
+        rejected: "rejected";
+        unauthorized: "unauthorized";
+        failure: "failure";
+    }>;
+}, z.core.$strip>;
+/**
+ * The final result an automation handler returns — its `outcome`. This is a
+ * terminal value (not a mutable status), so returning one ends the run:
+ *
+ * - `success` — the run succeeded.
+ * - `rejected` — the automation deliberately declined to act on the input (eg not an event it need run for).
+ * - `unauthorized` — the automation's own logic determined the caller was not
+ *   authorized to trigger this run (ex: incoming webhook validation failed).
+ * - `failure` — the run failed. Unhandled exceptions are also equivalent to this outcome.
+ */
+type AutomationResult = z.infer<typeof automationResultSchema>;
+declare const automationInvokeResultSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        success: "success";
+        rejected: "rejected";
+        unauthorized: "unauthorized";
+        failure: "failure";
+    }>;
+    logs: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type AutomationInvokeResult = z.infer<typeof automationInvokeResultSchema>;
+type AutomationRunOutcome = AutomationResult['outcome'] | 'timeout';
+
+export { type AutomationInvokeResult, type AutomationLogEntry, type AutomationResult, type AutomationRunOutcome, automationInvokeResultSchema, automationLogEntrySchema, automationResultSchema };

package/dist/schemas/index.mjs

@@ -0,0 +1,21 @@
+import "../chunk-I6KKUHEY.mjs";
+
+// src/schemas/index.ts
+import * as z from "zod";
+var automationLogEntrySchema = z.object({
+  level: z.enum(["info", "warning", "error"]),
+  message: z.string(),
+  /** ISO-8601 timestamp when this entry was logged. */
+  createdAt: z.string()
+});
+var automationResultSchema = z.object({
+  outcome: z.enum(["success", "rejected", "unauthorized", "failure"])
+});
+var automationInvokeResultSchema = automationResultSchema.extend({
+  logs: z.array(automationLogEntrySchema)
+});
+export {
+  automationInvokeResultSchema,
+  automationLogEntrySchema,
+  automationResultSchema
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@uniformdev/automations-sdk",
+  "version": "20.50.2-alpha.109+846837c66a",
+  "description": "Uniform Automations SDK",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.mts",
+      "import": "./dist/api/index.mjs"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/index.d.mts",
+      "import": "./dist/schemas/index.mjs"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.mts",
+      "import": "./dist/ai/index.mjs"
+    }
+  },
+  "types": "./dist/index.d.mts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "run-s update-openapi build:ts",
+    "build:ts": "tsup",
+    "dev": "run-s update-openapi dev:ts",
+    "dev:ts": "tsup --watch",
+    "clean": "rimraf dist src/openapi-types",
+    "test": "vitest run",
+    "lint": "eslint \"src/**/*.{js,ts,tsx}\"",
+    "format": "prettier --write \"src/**/*.{js,ts,tsx}\"",
+    "update-openapi": "tsx ./scripts/update-openapi.cts",
+    "document:prebuild": "api-extractor run --local"
+  },
+  "files": [
+    "/dist"
+  ],
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@uniformdev/context": "20.50.2-alpha.109+846837c66a",
+    "@uniformdev/webhooks": "20.50.2-alpha.109+846837c66a"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0",
+    "zod": "^4.3.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "ai": "6.0.168",
+    "zod": "4.3.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "846837c66ad0f518683c100615b59b27f91498ba"
+}