@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/setup/steps/instance.ts

@@ -1,206 +0,0 @@
-import chalk from 'chalk'
-
-import type { OwnedInstanceInfo } from '../../lib/admin-instance'
-import type { SetupContext, SetupStep } from '../types'
-
-import { AstraleError } from '../../errors'
-import { listOwnedInstancesWithIdentity } from '../../lib/admin-instance'
-import { normalizeInstanceKernelUrl, setActive, upsertManagedBookmark } from '../../lib/instance'
-import { readLocalStatus } from '../../lib/local-status'
-import { log, withSpinner } from '../../lib/log'
-import { renderInstanceHero } from '../../lib/panel'
-import { confirmDefaultYes, promptText, selectFrom } from '../../lib/prompt'
-import { provisionInstance, type ProvisionResult } from '../../lib/provision-instance'
-import { guiOrigin, slugError } from '../util'
-
-export type InstanceSetupDependencies = {
-  fetchOwned: (ctx: SetupContext) => Promise<{
-    readonly instances: OwnedInstanceInfo[]
-    readonly identity?: string
-  }>
-  adopt: (info: OwnedInstanceInfo, identity?: string) => Promise<void>
-  selectReady: (instances: OwnedInstanceInfo[]) => Promise<OwnedInstanceInfo | null>
-  confirmCreate: () => Promise<boolean>
-  promptSlug: () => Promise<string | undefined>
-  provision: (slug: string) => Promise<ProvisionResult>
-}
-
-export type OwnedInstanceAdoptionDependencies = {
-  upsert: typeof upsertManagedBookmark
-  activate: (slug: string) => Promise<unknown>
-}
-
-/** Print the click-inviting hero for a freshly-active instance. */
-function hero(slug: string, kernelUrl: string): void {
-  console.log('')
-  console.log(renderInstanceHero(slug, guiOrigin(kernelUrl)))
-  console.log('')
-}
-
-export async function adoptOwnedInstance(
-  info: OwnedInstanceInfo,
-  defaultIdentity?: string,
-  deps: OwnedInstanceAdoptionDependencies = {
-    upsert: upsertManagedBookmark,
-    activate: setActive,
-  },
-): Promise<void> {
-  const { repointedFrom } = await deps.upsert({
-    key: info.slug,
-    slug: info.slug,
-    url: info.url,
-    ...(info.organizationId ? { organizationId: info.organizationId } : {}),
-    ...(defaultIdentity ? { defaultIdentity } : {}),
-  })
-  await deps.activate(info.slug)
-  if (repointedFrom) {
-    log.warn(
-      `Bookmark "${info.slug}" repointed: ${repointedFrom} → ${normalizeInstanceKernelUrl(info.url)}`,
-    )
-  }
-  log.success(`Active instance: ${info.slug}`)
-  hero(info.slug, info.url)
-}
-
-function defaultDependencies(ctx: SetupContext): InstanceSetupDependencies {
-  return {
-    fetchOwned: (setupCtx) =>
-      withSpinner('Checking for existing instances', !setupCtx.machine, () =>
-        listOwnedInstancesWithIdentity(setupCtx.opts),
-      ),
-    adopt: adoptOwnedInstance,
-    selectReady: (instances) =>
-      selectFrom(
-        'No active instance. Pick one:',
-        instances.map((info) => ({
-          label: `${info.slug}  ${chalk.dim(guiOrigin(info.url))}`,
-          value: info,
-        })),
-      ),
-    confirmCreate: () => confirmDefaultYes('No instances yet. Provision your first one now?'),
-    promptSlug: () =>
-      ctx.slug
-        ? Promise.resolve(ctx.slug)
-        : promptText('Pick a slug for your instance', { validate: slugError }),
-    provision: (slug) => provisionInstance(slug, ctx.opts),
-  }
-}
-
-/**
- * Reconcile owner-scoped admin instances when no local active bookmark exists.
- * A failed ownership lookup is never treated as an empty account: setup stops
- * before creation so a transient auth/network failure cannot create a duplicate.
- */
-export async function ensureOwnedInstance(
-  ctx: SetupContext,
-  deps: InstanceSetupDependencies = defaultDependencies(ctx),
-): Promise<'fixed' | 'skipped'> {
-  let inventory: Awaited<ReturnType<InstanceSetupDependencies['fetchOwned']>>
-  try {
-    inventory = await deps.fetchOwned(ctx)
-  } catch (cause) {
-    const detail = cause instanceof Error ? cause.message : String(cause)
-    throw new AstraleError(
-      'INSTANCE_DISCOVERY_FAILED',
-      `Could not check your Astrale instances: ${detail}`,
-      'No instance was created. Check `astrale admin status`, then rerun `astrale setup`.',
-    )
-  }
-
-  const owned = inventory.instances
-
-  const ready = owned.filter((info) => info.state === 'ready')
-  if (ready.length === 1) {
-    await deps.adopt(ready[0]!, inventory.identity)
-    return 'fixed'
-  }
-
-  if (ready.length > 1) {
-    const choice = await deps.selectReady(ready)
-    if (choice === null) {
-      log.dim('  Skipped — no active instance set.')
-      return 'skipped'
-    }
-    await deps.adopt(choice, inventory.identity)
-    return 'fixed'
-  }
-
-  if (owned.length > 0) {
-    reportNotReady(owned)
-    return 'skipped'
-  }
-
-  if (!(await deps.confirmCreate())) {
-    log.dim('  Skipped — create one later: astrale instance create <slug>')
-    return 'skipped'
-  }
-
-  const slug = await deps.promptSlug()
-  if (!slug) {
-    log.dim('  Skipped — no slug given.')
-    return 'skipped'
-  }
-
-  const { created, selectionError } = await deps.provision(slug)
-  if (selectionError) {
-    const detail = selectionError instanceof Error ? selectionError.message : String(selectionError)
-    throw new AstraleError(
-      'INSTANCE_SELECTION_FAILED',
-      `Instance "${slug}" was provisioned, but the CLI could not select it: ${detail}`,
-      `Fix local CLI storage, then run \`astrale instance use ${slug}\`.`,
-    )
-  }
-  hero(slug, created.url)
-  return 'fixed'
-}
-
-function reportNotReady(instances: OwnedInstanceInfo[]): void {
-  log.warn(
-    `${instances.length === 1 ? 'Your instance is' : 'Your instances are'} not ready; setup will not create another.`,
-  )
-  for (const info of instances) {
-    const phase = info.phase && info.phase !== info.state ? ` (${info.phase})` : ''
-    log.dim(`  ${info.slug}: ${info.state}${phase} · astrale instance status ${info.slug}`)
-    if (info.error) log.dim(`    ${info.error}`)
-  }
-  if (instances.some((info) => info.state === 'failed')) {
-    log.dim(
-      '  Inspect the failure, then deliberately delete/recreate it with `astrale instance` commands.',
-    )
-  } else {
-    log.dim('  Wait for provisioning to finish, then rerun `astrale setup`.')
-  }
-}
-
-/**
- * Step 3 — an active instance, the heart of the flow. If the user already has
- * owned instances, adopt the sole ready one or ask among several; only a
- * confirmed empty owner list may fall through to first-instance provisioning.
- */
-export const instanceStep: SetupStep = {
-  id: 'instance',
-  title: 'Active instance',
-  group: 'connect',
-
-  async detect(ctx: SetupContext) {
-    const { instance } = await readLocalStatus()
-    if (instance) {
-      return { state: 'satisfied', summary: `${instance.active} (${guiOrigin(instance.url)})` }
-    }
-    return {
-      state: 'gap',
-      summary: 'No active instance',
-      fixHint: ctx.slug ? `astrale instance create ${ctx.slug}` : 'astrale instance create <slug>',
-    }
-  },
-
-  async ensure(ctx: SetupContext) {
-    const { instance } = await readLocalStatus()
-    if (instance) {
-      log.success(`Active instance: ${instance.active} (${guiOrigin(instance.url)})`)
-      return 'unchanged'
-    }
-
-    return ensureOwnedInstance(ctx)
-  },
-}

package/src/setup/steps/skills-bridge.ts

@@ -1,70 +0,0 @@
-import { existsSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { SetupStep } from '../types'
-
-import { log } from '../../lib/log'
-import { ensureSkillsBridge, skillsBridgeStatus } from '../../lib/skills'
-
-/**
- * Equip — make a workspace's own staged skills loadable. Agent tooling stages
- * skills under `.agents/skills`, but the harness (Claude Code et al.) only loads
- * `.claude/skills` (walking up to the project root). A single
- * `.claude/skills -> ../.agents/skills` symlink bridges every staged skill —
- * present and future — for this workspace and every project nested under it.
- * This is exactly how this monorepo wires its own skills; doing it in `setup`
- * means a skill landing in `.agents/skills` is loaded, not silently invisible
- * (the gap that let agent-browser report "installed" yet never load).
- *
- * Runs first in the equip group so the per-skill steps below detect against the
- * already-bridged state. Idempotent and non-destructive.
- */
-function countStaged(root: string): number {
-  try {
-    const dir = join(root, '.agents', 'skills')
-    return readdirSync(dir).filter((e) => existsSync(join(dir, e, 'SKILL.md'))).length
-  } catch {
-    return 0
-  }
-}
-
-export const skillsBridgeStep: SetupStep = {
-  id: 'skills-bridge',
-  title: 'workspace skills bridge',
-  group: 'equip',
-
-  async detect() {
-    const s = skillsBridgeStatus()
-    if (s.kind === 'none') return { state: 'satisfied', summary: 'no workspace skills to bridge' }
-    if (s.kind === 'bridged')
-      return { state: 'satisfied', summary: '.agents/skills bridged → the harness loads them' }
-    if (s.kind === 'foreign')
-      return { state: 'satisfied', summary: '.claude/skills already present — left as-is' }
-    const n = countStaged(s.root)
-    return {
-      state: 'gap',
-      summary: `${n} skill${n === 1 ? '' : 's'} in .agents/skills not loaded by the harness`,
-      fixHint: `ln -s ../.agents/skills ${s.link}`,
-    }
-  },
-
-  async ensure() {
-    const before = skillsBridgeStatus()
-    if (before.kind === 'none' || before.kind === 'bridged') return 'unchanged'
-    if (before.kind === 'foreign') {
-      log.dim('  .claude/skills already exists — leaving it untouched.')
-      return 'unchanged'
-    }
-    const after = ensureSkillsBridge()
-    if (after.kind === 'bridged') {
-      log.success(
-        `Workspace skills bridged — ${join(after.root, '.agents/skills')} → .claude/skills`,
-      )
-      return 'fixed'
-    }
-    log.warn(
-      'Could not create the skills bridge — create it manually: ln -s ../.agents/skills .claude/skills',
-    )
-    return 'failed'
-  },
-}

package/src/setup/steps/skills.ts

@@ -1,61 +0,0 @@
-import type { SetupStep } from '../types'
-
-import { log } from '../../lib/log'
-import { checkAstraleSkills, SKILL_INSTALL_HINT, syncAstraleSkills } from '../../lib/skills'
-
-const FIX = SKILL_INSTALL_HINT
-
-/**
- * Equip — reconcile every top-level Astrale-owned skill from astrale-os/cli main.
- * Setup and update deliberately share one owner, so an existence-only setup check
- * can never bless an incomplete or stale global cohort.
- */
-export const skillsStep: SetupStep = {
-  id: 'skills',
-  title: 'Astrale agent skills',
-  group: 'equip',
-
-  async detect() {
-    const result = await checkAstraleSkills()
-    if (result.status === 'current') {
-      return { state: 'satisfied', summary: 'Astrale skills are installed and up to date' }
-    }
-    if (result.status === 'unavailable') {
-      return {
-        state: 'broken',
-        summary: 'Astrale skills could not be verified',
-        detail: result.error,
-        fixHint: FIX,
-      }
-    }
-    return {
-      state: 'gap',
-      summary:
-        result.status === 'repair-needed'
-          ? 'Astrale skills need repair'
-          : 'Astrale skills need installation or update',
-      fixHint: FIX,
-    }
-  },
-
-  async ensure() {
-    log.step('Ensuring Astrale agent skills are current and healthy')
-    try {
-      const result = await syncAstraleSkills()
-      if (result.status === 'unchanged') {
-        log.success('Astrale skills already up to date')
-        return 'unchanged'
-      }
-      if (result.status === 'installed') log.success('Astrale skills installed')
-      else if (result.status === 'updated') log.success('Astrale skills updated')
-      else if (result.status === 'repaired') log.success('Astrale skills repaired and updated')
-      return 'fixed'
-    } catch (error) {
-      log.warn(
-        `Astrale skills could not be installed safely${error instanceof Error ? `: ${error.message}` : ''}`,
-      )
-      log.dim(`  Retry: ${FIX}`)
-      return 'failed'
-    }
-  },
-}

package/src/setup/types.ts

@@ -1,61 +0,0 @@
-import type { AdminTargetCommandOpts } from '../lib/admin-target'
-
-/**
- * The setup reconciler models onboarding as a list of small, independent steps,
- * each able to (a) `detect` its state without side effects and (b) `ensure` its
- * state interactively, taking the user by the hand. `detect` powers the
- * read-only plan + checklist (and the agent-facing `--plan` JSON); `ensure` is
- * the hand-held fix. Both are idempotent — re-running setup when everything is
- * already satisfied just prints a row of ✔.
- */
-
-export type StepState = 'satisfied' | 'gap' | 'broken'
-
-export type StepDetection = {
-  state: StepState
-  /** One-line status for the checklist (no symbol — the renderer adds it). */
-  summary: string
-  /** Optional dim detail line. */
-  detail?: string
-  /** The granular command an agent (or a human) would run to close the gap. */
-  fixHint?: string
-}
-
-export type StepOutcome = 'fixed' | 'unchanged' | 'skipped' | 'failed'
-
-export type SetupOpts = AdminTargetCommandOpts & {
-  /** Read-only: print the plan and exit without mutating anything. */
-  plan?: boolean
-  json?: boolean
-  raw?: boolean
-  // Global flags (program.ts) that force non-interactive.
-  ci?: boolean
-  noPrompt?: boolean
-  // Threaded into admin-kernel calls (provisioning, instance listing).
-  as?: string
-  creds?: string
-  timeout?: string
-  debug?: boolean
-}
-
-export type SetupContext = {
-  /** TTY and not --ci / --no-prompt / CI: ok to prompt and mutate. */
-  interactive: boolean
-  /** isMachine(opts): --json / --raw or piped — structured output, no spinners. */
-  machine: boolean
-  opts: SetupOpts
-  /** Instance slug hint from the positional arg, used when provisioning. */
-  slug?: string
-}
-
-export type StepGroup = 'connect' | 'equip'
-
-export type SetupStep = {
-  id: string
-  title: string
-  group: StepGroup
-  /** Read-only probe for the plan + checklist. Never prompts, never mutates. */
-  detect: (ctx: SetupContext) => Promise<StepDetection>
-  /** Interactive, idempotent hand-holding. May print rich output (e.g. a hero). */
-  ensure: (ctx: SetupContext) => Promise<StepOutcome>
-}

package/src/setup/util.ts

@@ -1,34 +0,0 @@
-import { validateSlug, validateUrl } from '../lib/validation'
-
-/**
- * The clickable GUI origin for an instance — its kernel URL stripped of the
- * `/api` path bookmarks carry (`https://app.eu.astrale.ai/api` →
- * `https://app.eu.astrale.ai`). This is the URL we put in front of the user.
- */
-export function guiOrigin(kernelUrl: string): string {
-  try {
-    return new URL(kernelUrl).origin
-  } catch {
-    return kernelUrl
-  }
-}
-
-/** inquirer `validate`: true when the slug is valid, else the human message. */
-export function slugError(value: string): true | string {
-  try {
-    validateSlug(value)
-    return true
-  } catch (e) {
-    return e instanceof Error ? e.message : 'Invalid slug'
-  }
-}
-
-/** inquirer `validate`: true when the value is an http(s) URL, else the message. */
-export function urlError(value: string): true | string {
-  try {
-    validateUrl(value)
-    return true
-  } catch (e) {
-    return e instanceof Error ? e.message : 'Invalid URL'
-  }
-}

package/src/state/.spec/api.d.ts

@@ -1,152 +0,0 @@
-import type { SessionRouteArtifact, SessionRouteStore } from '@astrale-os/sdk/client/session'
-
-/** Environment values that affect CLI-owned state placement. */
-export interface PathEnvironment {
-  readonly ASTRALE_HOME?: string
-  readonly ASTRALE_KEYS_DIR?: string
-  readonly ASTRALE_DATA_DIR?: string
-}
-
-/** One captured set of CLI-owned durable-state coordinates. */
-export interface Paths {
-  readonly home: string
-  readonly keys: string
-  readonly data: string
-  readonly config: string
-  readonly install: string
-  readonly identities: string
-  readonly instances: string
-  readonly idps: string
-  readonly idpSessionsDir: string
-  readonly exchangeCredentials: string
-  readonly sessionRoutes: string
-  idpDir(name: string): string
-  idpSession(identityName: string): string
-}
-
-/** Resolve explicit home, environment overrides, and platform home exactly once. */
-export function createPaths(home?: string, environment?: PathEnvironment): Paths
-
-export const paths: Paths
-export const ASTRALE_HOME: string
-export const KEYS_DIR: string
-export const DATA_DIR: string
-export const CONFIG_PATH: string
-export const INSTALL_PATH: string
-export const IDENTITIES_PATH: string
-export const INSTANCES_PATH: string
-export const IDPS_PATH: string
-export const IDP_SESSIONS_DIR: string
-export const EXCHANGE_CREDENTIALS_PATH: string
-export const SESSION_ROUTES_PATH: string
-
-export namespace exchange {
-  interface Artifact {
-    readonly version: 2
-    readonly entries: Record<string, Entry>
-  }
-
-  interface Key {
-    readonly kernelIssuer: string
-    readonly domainIssuer: string
-    readonly sourceIssuer: string
-    readonly sourceSubject: string
-  }
-
-  interface Entry {
-    readonly credential: string
-    readonly expiresAt: number
-    readonly user: string
-    readonly sourceIssuer: string
-    readonly sourceSubject: string
-  }
-}
-
-/** Persist exact Domain bearer tokens under a private, cross-process synchronized cache. */
-export class ExchangeCredentialCache {
-  constructor(path?: string)
-  getOrRefresh(
-    key: exchange.Key,
-    refresh: () => Promise<exchange.Entry>,
-    now?: () => number,
-  ): Promise<string>
-  deleteKernel(kernelIssuer: string): Promise<void>
-  clear(): Promise<void>
-}
-
-export type IdentitySource = 'key' | 'idp'
-export type IdentityMode = 'local' | 'remote'
-
-export interface Registration {
-  readonly iss: string
-  readonly sub: string
-  readonly registeredAt: string
-}
-
-export interface Identity {
-  readonly subject: string
-  readonly createdAt: string
-  readonly source?: IdentitySource
-  readonly mode?: IdentityMode
-  readonly kid?: string
-  readonly idp?: string
-  readonly issuer?: string
-  readonly audience?: string
-  readonly claims?: Readonly<Record<string, unknown>>
-  readonly registrations?: Readonly<Record<string, Registration>>
-}
-
-/** Decoded semantic identity state; persistence-version metadata is not exposed to consumers. */
-export interface IdentityStore {
-  readonly default: string
-  readonly identities: Readonly<Record<string, Identity>>
-}
-
-export const IDENTITY_STORE_VERSION: 1
-
-export interface IdentityStoreOptions {
-  readonly path?: string
-  readonly now?: () => Date
-  readonly lock?: FileLockOptions
-}
-
-export interface IdentityUpdate<Value> {
-  readonly next: IdentityStore
-  readonly value: Value
-}
-
-/** Decode the missing, legacy, or current identity file without writing or migrating it. */
-export function readIdentityStore(options?: IdentityStoreOptions): Promise<IdentityStore>
-
-/** Reread and commit one identity transition under the file's cross-process lock. */
-export function updateIdentityStore<Value>(
-  transition: (current: IdentityStore) => IdentityUpdate<Value> | Promise<IdentityUpdate<Value>>,
-  options?: IdentityStoreOptions,
-): Promise<Value>
-
-/** Atomically replace one private CLI state file through a same-directory temporary file. */
-export function atomicWrite(path: string, data: string): Promise<void>
-export function atomicWriteSync(path: string, data: string): void
-
-/** CLI filesystem representation for Kernel Client's admitted confidential route artifact. */
-export class FileSessionRouteStore implements SessionRouteStore {
-  constructor(path?: string)
-  read(): unknown
-  write(artifact: SessionRouteArtifact): void
-  clear(): void
-}
-
-export const SESSION_ROUTE_STORE: Readonly<FileSessionRouteStore>
-
-export interface FileLockOptions {
-  readonly pollIntervalMs?: number
-  readonly staleAfterMs?: number
-  readonly timeoutMs?: number
-}
-
-/** Run one state transition under a bounded cross-process file lock. */
-export function withFileLock<Value>(
-  lockPath: string,
-  transition: () => Promise<Value>,
-  options?: FileLockOptions,
-): Promise<Value>

package/src/state/.spec/architecture.md

@@ -1,45 +0,0 @@
-# CLI state architecture
-
-This module owns CLI filesystem placement, the durable file-transition primitives shared by state
-registries, and each registry's persistence admission. `createPaths` captures explicit and
-environment coordinates once. `atomicWrite` publishes one complete `0600` file through a
-same-directory temporary file. `withFileLock` bounds cross-process read-modify-write exclusion and
-releases its lock on every terminal path.
-
-The identity registry decodes the legacy unversioned shape and current V1 envelope into one semantic
-`IdentityStore`. Reads never migrate. The first successful mutation of a legacy file preserves its
-exact bytes at `identities.json.v0.bak` before publishing V1. Invalid or newer files remain untouched
-and fail closed. Identity orchestration owns key and IdP-session effects above this module.
-
-The exchange registry owns a versioned `exchange.Artifact`. Each V2 entry is keyed by the atomic
-`(Kernel issuer, Domain issuer, source issuer, source subject)` identity and stores one inspected
-Domain credential, expiry, and the exact registered Kernel User proven when that credential was
-minted, together with the exact upstream source issuer and subject that selected the entry. This lets
-a warm command validate and reuse the credential before any network `whoami` without accepting a
-refresh result filed under another source identity.
-V1 is not migrated or retained; it is discarded and replaced by the next exact exchange. The
-registry reuses the same atomic-write and bounded file-lock primitives and maintains owner-only
-directory and file modes.
-
-The session-route registry is a separate representation adapter for Kernel Client's versioned,
-bounded confidential route artifact. Kernel Client exclusively owns route keying, admission, expiry,
-and stale/miss recovery. CLI owns only synchronous owner-private JSON I/O so a new CLI process can
-reuse admitted routing state without an Admin-specific shortcut. Writes are atomic snapshots; a
-lost concurrent cache update or any read/write failure is only a future cold route miss and cannot
-change product correctness.
-Authentication logout and identity deletion remove this artifact together with exchanged Domain
-credentials so locally retired authority does not leave reusable destination bearers behind.
-
-Shape decoding, migrations, and backup policy remain with each semantic registry. Commands do not
-call these primitives directly, and Kernel Client owns no CLI filesystem state.
-
-```mermaid
-flowchart LR
-  C[CLI command] --> I[identity orchestration]
-  I --> R[IdentityStore transition]
-  R --> L[withFileLock]
-  L --> B[legacy backup when needed]
-  B --> A[atomicWrite V1]
-  A --> F[identities.json]
-  P[createPaths] --> R
-```

package/src/state/.spec/capabilities/state.ts

@@ -1,7 +0,0 @@
-import { defineCapability } from '@astrale-os/spec/authoring'
-
-export const CLI_STATE = defineCapability({
-  id: 'CLI-STATE',
-  statement:
-    'Owns captured CLI filesystem coordinates and bounded atomic transitions for local durable state.',
-})

package/src/state/.spec/flows/identity-update.ts

@@ -1,22 +0,0 @@
-import type { IdentityStore, IdentityUpdate } from '../api.js'
-
-declare const withIdentityLock: <Value>(transition: () => Promise<Value>) => Promise<Value>
-declare const readLatest: () => Promise<{
-  readonly store: IdentityStore
-  readonly legacyBytes?: string
-}>
-declare const preserveLegacyBackup: (bytes: string) => Promise<void>
-declare const publishV1: (store: IdentityStore) => Promise<void>
-
-/** One identity mutation rereads, transitions, backs up legacy bytes, then publishes exactly once. */
-export function updateIdentity<Value>(
-  transition: (current: IdentityStore) => IdentityUpdate<Value> | Promise<IdentityUpdate<Value>>,
-): Promise<Value> {
-  return withIdentityLock(async () => {
-    const current = await readLatest()
-    const update = await transition(current.store)
-    if (current.legacyBytes !== undefined) await preserveLegacyBackup(current.legacyBytes)
-    await publishV1(update.next)
-    return update.value
-  })
-}