@sealant/api-contracts-next 0.39.0-next.694 → 0.39.0-next.696

package/dist/capture-owner-map.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The owner map of a capture workspace (sealantd ADR-0015 "Per-person saved directories", Mend's
+ * ADR 0016 decision 8): who owns what the daemon's restore writes, and so whether its executor is a
+ * per-person one. The ONE definition of its shape, its bounds and its wire encoding, shared by the
+ * SDK (client-side refusal with the server's wording), the control-plane validators (every parse:
+ * create, worker, restart) and the runtime adapters (the boot env).
+ *
+ * The daemon reads it from its boot environment as `SEALANT_CAPTURE_OWNER_MAP`, JSON
+ * `{"gid":…,"worktree":…,"people":{"<id>":uid,…}}`, parsed strictly (unknown fields refused):
+ *
+ * - each listed person's saved directory (`<harness home>/people/<id>/`) is restored owned by their
+ *   uid and the group, the directory itself 0710, its `conversations/` group-readable and -writable;
+ * - the worktree and its git directory are given to the group (owned by `worktreeUid`, setgid, the
+ *   owner's bits copied to the group);
+ * - a root daemon whose map names at least one person does not set no-new-privileges, so every
+ *   person's passwordless `sudo` works. A map naming nobody keeps it.
+ *
+ * Deliberately dependency-free, like `workspace-environment.ts`: data plus pure functions.
+ */
+/** The daemon's name for the owner map in its boot environment. */
+export declare const CAPTURE_OWNER_MAP_ENV = "SEALANT_CAPTURE_OWNER_MAP";
+/** The shared group every person is in: Mend's `mend`, the reserved range's first id. */
+export declare const CAPTURE_OWNER_MAP_GID = 40000;
+/**
+ * The uids people may have: the reserved range (40000–49999) less its first id, the group's. The
+ * managed images leave the whole range free (their probe checks it).
+ */
+export declare const CAPTURE_OWNER_MAP_UID_RANGE: {
+    readonly first: 40001;
+    readonly last: 49999;
+};
+/** At most this many people in one map. */
+export declare const CAPTURE_OWNER_MAP_MAX_PEOPLE = 256;
+/**
+ * A person's id: the name of their saved directory under `people/` (Mend's account id). One plain
+ * path component of at most 128 characters that starts with a letter, a digit or `_` (so never `.`
+ * or `..`).
+ */
+export declare const CAPTURE_OWNER_MAP_ID_PATTERN: RegExp;
+/** One person in an owner map. */
+export interface CaptureOwnerMapPerson {
+    /** The name of their saved directory under `<harness home>/people/` (Mend's account id). */
+    readonly id: string;
+    /** Their Linux uid, in {@link CAPTURE_OWNER_MAP_UID_RANGE}. */
+    readonly uid: number;
+}
+/** Who owns what a capture restore writes. */
+export interface CaptureOwnerMap {
+    /** The shared group every person is in: {@link CAPTURE_OWNER_MAP_GID}. */
+    readonly gid: number;
+    /** The change's owner: owns the worktree root and its git directory. */
+    readonly worktreeUid: number;
+    /** Each current member. A removed member is left out: their directory is restored root's. */
+    readonly people: ReadonlyArray<CaptureOwnerMapPerson>;
+}
+/**
+ * What is wrong with a map, in the words the control plane answers with; empty when nothing is.
+ * Checks the gid, every uid's range, every id's form, and that no id and no uid appears twice (one
+ * person's saved directory is never handed to another).
+ */
+export declare const captureOwnerMapProblems: (map: CaptureOwnerMap) => readonly string[];
+/**
+ * The map as the daemon parses it (`SEALANT_CAPTURE_OWNER_MAP`): compact JSON, `people` an object
+ * keyed by id in code-point order (the daemon's own order), always present.
+ */
+export declare const encodeCaptureOwnerMap: (map: CaptureOwnerMap) => string;

package/dist/capture-owner-map.js

@@ -0,0 +1,104 @@
+/**
+ * The owner map of a capture workspace (sealantd ADR-0015 "Per-person saved directories", Mend's
+ * ADR 0016 decision 8): who owns what the daemon's restore writes, and so whether its executor is a
+ * per-person one. The ONE definition of its shape, its bounds and its wire encoding, shared by the
+ * SDK (client-side refusal with the server's wording), the control-plane validators (every parse:
+ * create, worker, restart) and the runtime adapters (the boot env).
+ *
+ * The daemon reads it from its boot environment as `SEALANT_CAPTURE_OWNER_MAP`, JSON
+ * `{"gid":…,"worktree":…,"people":{"<id>":uid,…}}`, parsed strictly (unknown fields refused):
+ *
+ * - each listed person's saved directory (`<harness home>/people/<id>/`) is restored owned by their
+ *   uid and the group, the directory itself 0710, its `conversations/` group-readable and -writable;
+ * - the worktree and its git directory are given to the group (owned by `worktreeUid`, setgid, the
+ *   owner's bits copied to the group);
+ * - a root daemon whose map names at least one person does not set no-new-privileges, so every
+ *   person's passwordless `sudo` works. A map naming nobody keeps it.
+ *
+ * Deliberately dependency-free, like `workspace-environment.ts`: data plus pure functions.
+ */
+/** The daemon's name for the owner map in its boot environment. */
+export const CAPTURE_OWNER_MAP_ENV = "SEALANT_CAPTURE_OWNER_MAP";
+/** The shared group every person is in: Mend's `mend`, the reserved range's first id. */
+export const CAPTURE_OWNER_MAP_GID = 40_000;
+/**
+ * The uids people may have: the reserved range (40000–49999) less its first id, the group's. The
+ * managed images leave the whole range free (their probe checks it).
+ */
+export const CAPTURE_OWNER_MAP_UID_RANGE = { first: 40_001, last: 49_999 };
+/** At most this many people in one map. */
+export const CAPTURE_OWNER_MAP_MAX_PEOPLE = 256;
+/**
+ * A person's id: the name of their saved directory under `people/` (Mend's account id). One plain
+ * path component of at most 128 characters that starts with a letter, a digit or `_` (so never `.`
+ * or `..`).
+ */
+export const CAPTURE_OWNER_MAP_ID_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$/u;
+const isUid = (value) => Number.isInteger(value) &&
+    value >= CAPTURE_OWNER_MAP_UID_RANGE.first &&
+    value <= CAPTURE_OWNER_MAP_UID_RANGE.last;
+const UID_RANGE_TEXT = `${CAPTURE_OWNER_MAP_UID_RANGE.first}–${CAPTURE_OWNER_MAP_UID_RANGE.last}`;
+/**
+ * What is wrong with a map, in the words the control plane answers with; empty when nothing is.
+ * Checks the gid, every uid's range, every id's form, and that no id and no uid appears twice (one
+ * person's saved directory is never handed to another).
+ */
+export const captureOwnerMapProblems = (map) => {
+    // A plain JavaScript caller may hand anything: refused in words, never a TypeError.
+    const shape = map;
+    if (typeof shape !== "object" || shape === null) {
+        return ["ownerMap must be an object { gid, worktreeUid, people }"];
+    }
+    if (!Array.isArray(map.people)) {
+        return ["ownerMap.people must be an array of { id, uid }"];
+    }
+    const problems = [];
+    if (map.gid !== CAPTURE_OWNER_MAP_GID) {
+        problems.push(`ownerMap.gid must be ${CAPTURE_OWNER_MAP_GID} (the mend group), not ${map.gid}`);
+    }
+    if (!isUid(map.worktreeUid)) {
+        problems.push(`ownerMap.worktreeUid ${map.worktreeUid} is not a uid in ${UID_RANGE_TEXT}`);
+    }
+    if (map.people.length > CAPTURE_OWNER_MAP_MAX_PEOPLE) {
+        problems.push(`ownerMap.people has ${map.people.length} people; the maximum is ${CAPTURE_OWNER_MAP_MAX_PEOPLE}`);
+        return problems;
+    }
+    const ids = new Set();
+    const uids = new Map();
+    for (const [index, person] of map.people.entries()) {
+        const entry = person;
+        if (typeof entry !== "object" || entry === null) {
+            problems.push(`ownerMap.people[${index}] must be an object { id, uid }`);
+            continue;
+        }
+        if (typeof person.id !== "string" || !CAPTURE_OWNER_MAP_ID_PATTERN.test(person.id)) {
+            problems.push(`ownerMap.people[${index}].id must be one directory name of letters, digits, '.', '_' or '-' (at most 128, not starting with '.' or '-')`);
+            continue;
+        }
+        if (ids.has(person.id)) {
+            problems.push(`ownerMap.people names ${person.id} twice`);
+        }
+        ids.add(person.id);
+        if (!isUid(person.uid)) {
+            problems.push(`ownerMap.people ${person.id} has uid ${person.uid}, not a uid in ${UID_RANGE_TEXT}`);
+            continue;
+        }
+        const other = uids.get(person.uid);
+        if (other !== undefined && other !== person.id) {
+            problems.push(`ownerMap.people gives ${other} and ${person.id} the same uid ${person.uid}`);
+        }
+        uids.set(person.uid, person.id);
+    }
+    return problems;
+};
+/**
+ * The map as the daemon parses it (`SEALANT_CAPTURE_OWNER_MAP`): compact JSON, `people` an object
+ * keyed by id in code-point order (the daemon's own order), always present.
+ */
+export const encodeCaptureOwnerMap = (map) => {
+    // `fromEntries` defines own properties, so an id such as `__proto__` stays a key.
+    const people = Object.fromEntries(map.people
+        .toSorted((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+        .map((person) => [person.id, person.uid]));
+    return JSON.stringify({ gid: map.gid, worktree: map.worktreeUid, people });
+};

package/dist/core-api/control-plane.d.ts

@@ -462,7 +462,7 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
     readonly recordDeletedAt: import("effect/Schema").optional<import("effect/Schema").String>;
     readonly createdAt: import("effect/Schema").String;
     readonly updatedAt: import("effect/Schema").String;
-}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./runs.js").RunNotFoundError | typeof import("./runs.js").RunInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getRunChanges", "GET", "/v1/runs/:runId/changes", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./budgets.ts").BudgetExceededError | typeof import("./runs.js").RunNotFoundError | typeof import("./runs.js").RunInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getRunChanges", "GET", "/v1/runs/:runId/changes", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly runId: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly ownerUserId: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -1026,6 +1026,7 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
         readonly runningMs: import("effect/Schema").Number;
         readonly boundMs: import("effect/Schema").Number;
     }>>;
+    readonly ownerMap: import("effect/Schema").optional<import("effect/Schema").Boolean>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getWorkspace", "GET", "/v1/workspaces/:workspaceId", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly workspaceId: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
@@ -1164,6 +1165,7 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
         readonly runningMs: import("effect/Schema").Number;
         readonly boundMs: import("effect/Schema").Number;
     }>>;
+    readonly ownerMap: import("effect/Schema").optional<import("effect/Schema").Boolean>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getWorkspaceCreate", "GET", "/v1/workspaces/idempotency-keys/:idempotencyKey", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly idempotencyKey: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
@@ -1410,6 +1412,14 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
     readonly workspaceId: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly ownerUserId: import("effect/Schema").String;
+    readonly expectedOwnerMap: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        readonly gid: import("effect/Schema").Number;
+        readonly worktreeUid: import("effect/Schema").Number;
+        readonly people: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").String;
+            readonly uid: import("effect/Schema").Number;
+        }>>;
+    }>>>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly worktreeId: import("effect/Schema").String;
     readonly epoch: import("effect/Schema").Number;

package/dist/core-api/runs.d.ts

@@ -380,7 +380,7 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
     readonly recordDeletedAt: Schema.optional<Schema.String>;
     readonly createdAt: Schema.String;
     readonly updatedAt: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunChanges", "GET", "/:runId/changes", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.Json<typeof BudgetExceededError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunChanges", "GET", "/:runId/changes", HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly runId: Schema.String;
 }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly ownerUserId: Schema.optional<Schema.String>;

package/dist/core-api/runs.js

@@ -258,7 +258,8 @@ export const RunsGroup = HttpApiGroup.make("runs")
     params: runIdParams,
     query: runOwnerQuerySchema,
     success: runSchema,
-    error: [RunNotFoundError, RunInternalServerError],
+    // The per-credential request budget answers 429 before any handler runs.
+    error: [BudgetExceededError, RunNotFoundError, RunInternalServerError],
 }))
     .add(HttpApiEndpoint.patch("updateRun", "/:runId", {
     params: runIdParams,

package/dist/core-api/workspaces.d.ts

@@ -406,6 +406,12 @@ export declare const workspaceCaptureStatusSchema: Schema.Struct<{
         readonly runningMs: Schema.Number;
         readonly boundMs: Schema.Number;
     }>>;
+    /**
+     * The executor booted under an owner map (`SEALANT_CAPTURE_OWNER_MAP`): its restores give each
+     * mapped person's saved directory to them and the worktree to the group. Absent from a control
+     * plane that predates it; false from a daemon that predates it.
+     */
+    readonly ownerMap: Schema.optional<Schema.Boolean>;
 }>;
 export type WorkspaceCaptureStatus = typeof workspaceCaptureStatusSchema.Type;
 /**
@@ -417,6 +423,21 @@ export type WorkspaceCaptureStatus = typeof workspaceCaptureStatusSchema.Type;
  */
 export declare const replanWorkspaceCaptureRequestSchema: Schema.Struct<{
     readonly ownerUserId: Schema.String;
+    /**
+     * The owner map the claim needs (a capture source's `ownerMap`), or `null` for none. The daemon
+     * reads its map only at boot, so a re-plan restores under the map the executor was launched
+     * with: when this is given and differs from that map (including a standby launched with none),
+     * the re-plan is refused with `409` code `owner-map-mismatch` before the daemon is reached.
+     * Omitted, nothing is compared.
+     */
+    readonly expectedOwnerMap: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly gid: Schema.Number;
+        readonly worktreeUid: Schema.Number;
+        readonly people: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly uid: Schema.Number;
+        }>>;
+    }>>>;
 }>;
 export type ReplanWorkspaceCaptureRequest = typeof replanWorkspaceCaptureRequestSchema.Type;
 export declare const workspaceCaptureReplannedSchema: Schema.Struct<{
@@ -1705,6 +1726,12 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
         readonly runningMs: Schema.Number;
         readonly boundMs: Schema.Number;
     }>>;
+    /**
+     * The executor booted under an owner map (`SEALANT_CAPTURE_OWNER_MAP`): its restores give each
+     * mapped person's saved directory to them and the worktree to the group. Absent from a control
+     * plane that predates it; false from a daemon that predates it.
+     */
+    readonly ownerMap: Schema.optional<Schema.Boolean>;
 }>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getWorkspace", "GET", "/:workspaceId", HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly workspaceId: Schema.String;
 }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
@@ -1956,6 +1983,12 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
         readonly runningMs: Schema.Number;
         readonly boundMs: Schema.Number;
     }>>;
+    /**
+     * The executor booted under an owner map (`SEALANT_CAPTURE_OWNER_MAP`): its restores give each
+     * mapped person's saved directory to them and the worktree to the group. Absent from a control
+     * plane that predates it; false from a daemon that predates it.
+     */
+    readonly ownerMap: Schema.optional<Schema.Boolean>;
 }>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getWorkspaceCreate", "GET", "/idempotency-keys/:idempotencyKey", HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly idempotencyKey: Schema.String;
 }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
@@ -2290,6 +2323,21 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
     readonly workspaceId: Schema.String;
 }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
     readonly ownerUserId: Schema.String;
+    /**
+     * The owner map the claim needs (a capture source's `ownerMap`), or `null` for none. The daemon
+     * reads its map only at boot, so a re-plan restores under the map the executor was launched
+     * with: when this is given and differs from that map (including a standby launched with none),
+     * the re-plan is refused with `409` code `owner-map-mismatch` before the daemon is reached.
+     * Omitted, nothing is compared.
+     */
+    readonly expectedOwnerMap: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly gid: Schema.Number;
+        readonly worktreeUid: Schema.Number;
+        readonly people: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly uid: Schema.Number;
+        }>>;
+    }>>>;
 }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
     readonly worktreeId: Schema.String;
     readonly epoch: Schema.Number;

package/dist/core-api/workspaces.js

@@ -357,6 +357,12 @@ export const workspaceCaptureStatusSchema = Schema.Struct({
      * past its bound, and from a daemon or control plane that predates it.
      */
     overdue: Schema.optional(captureOverdueSchema),
+    /**
+     * The executor booted under an owner map (`SEALANT_CAPTURE_OWNER_MAP`): its restores give each
+     * mapped person's saved directory to them and the worktree to the group. Absent from a control
+     * plane that predates it; false from a daemon that predates it.
+     */
+    ownerMap: Schema.optional(Schema.Boolean),
 });
 /**
  * Re-plan a capture-sourced workspace (sealantd 0.15 `capture.replan`, the claim hook): the daemon
@@ -367,6 +373,18 @@ export const workspaceCaptureStatusSchema = Schema.Struct({
  */
 export const replanWorkspaceCaptureRequestSchema = Schema.Struct({
     ownerUserId: NonEmptyString,
+    /**
+     * The owner map the claim needs (a capture source's `ownerMap`), or `null` for none. The daemon
+     * reads its map only at boot, so a re-plan restores under the map the executor was launched
+     * with: when this is given and differs from that map (including a standby launched with none),
+     * the re-plan is refused with `409` code `owner-map-mismatch` before the daemon is reached.
+     * Omitted, nothing is compared.
+     */
+    expectedOwnerMap: Schema.optional(Schema.NullOr(Schema.Struct({
+        gid: Schema.Number,
+        worktreeUid: Schema.Number,
+        people: Schema.Array(Schema.Struct({ id: Schema.String, uid: Schema.Number })),
+    }))),
 });
 export const workspaceCaptureReplannedSchema = Schema.Struct({
     worktreeId: NonEmptyString,

package/dist/index.d.ts

@@ -16,3 +16,4 @@ export * from "./core-api/ssh-keys.js";
 export * from "./core-api/system.js";
 export * from "./core-api/users.js";
 export * from "./workspace-environment.js";
+export * from "./capture-owner-map.js";

package/dist/index.js

@@ -16,3 +16,4 @@ export * from "./core-api/ssh-keys.js";
 export * from "./core-api/system.js";
 export * from "./core-api/users.js";
 export * from "./workspace-environment.js";
+export * from "./capture-owner-map.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/api-contracts-next",
-  "version": "0.39.0-next.694",
+  "version": "0.39.0-next.696",
   "description": "Contract-first HTTP API definitions for Sealant services",
   "license": "Apache-2.0",
   "repository": {
@@ -17,6 +17,10 @@
     "./workspace-environment": {
       "types": "./dist/workspace-environment.d.ts",
       "import": "./dist/workspace-environment.js"
+    },
+    "./capture-owner-map": {
+      "types": "./dist/capture-owner-map.d.ts",
+      "import": "./dist/capture-owner-map.js"
     }
   },
   "files": [
@@ -28,7 +32,7 @@
   "peerDependencies": {
     "effect": ">=4.0.0-beta.85 <5"
   },
-  "gitHead": "a8b2d5ce98ebd6c83e059122320f7384fab3f233",
+  "gitHead": "55326dd1cfb131e4324cecc5cd896f5bee35980c",
   "publishConfig": {
     "access": "public"
   }