@3sln/trove 0.0.7 → 0.0.9

package/packages/web/src/bl/services.js

@@ -1,154 +1,42 @@
-// Reactive data services the workbench renders from. These hold *data* state
-// (the current collection's items, search results, in-flight transfers) as
-// opposed to the shell's UI state (WorkbenchService). ngin Actions mutate them;
-// the UI `watch`es them. Each is a plain cell wrapper so the render layer stays
-// declarative.
+// What is left of the data services, plus the derivations that were methods on them.
+//
+// The explorer, search and API-key services were state bags — a `state`, a `cell`, and a
+// `set` that wrote both — and are slices now (bl/state.js). TransfersService stays,
+// because it holds things a state snapshot cannot: AbortControllers, per-file retry
+// thunks closing over the File itself, and a projection into the activity list.
+//
+// The functions below were METHODS on those bags. They are derivations, so they belong to
+// whoever is asking rather than to whatever happens to hold the data.
 
 import { cell } from '../runtime.js';
 
-export class ExplorerService {
-  constructor(settings) {
-    this.settings = settings;
-    this.state = {
-      items: [], loading: false, error: null,
-      selection: [], sort: settings.get('explorer.sort'), order: settings.get('explorer.sortOrder'),
-      // No collection until one is chosen or created. `gate` is 'create' | 'choose' | null
-      // — when set, it is the ONLY thing the workbench shows, because every request needs
-      // a collection and there is nothing sensible to render without one.
-      collectionId: null, collections: [], canCreateCollection: false, gate: null,
-      // `stats` is the whole collection; `items` is the page on screen. Keeping both
-      // is what lets the UI say "500 of 3,006" instead of quietly claiming 500.
-      stats: null, usage: null, nextCursor: null, loadingMore: false, trash: null,
-    };
-    this.cell = cell(this.state);
-  }
-  observe() {
-    return this.cell;
-  }
-  set(patch) {
-    this.state = { ...this.state, ...patch };
-    this.cell.setValue(this.state);
-  }
-  /**
-   * @param {string[]} ids
-   * @param {{additive?: boolean, nodes?: object[]}} [opts] `nodes` is the caller's own
-   *   copy of what it selected — pass it whenever you have it (see selectedNodes).
-   */
-  select(ids, { additive = false, nodes = null } = {}) {
-    const next = additive ? Array.from(new Set([...this.state.selection, ...ids])) : ids;
-    // Selecting what is already selected must not emit. The launcher syncs the
-    // highlighted row into here on every mouseenter, and a state push per mouse move
-    // would re-render the list under the pointer.
-    const same = next.length === this.state.selection.length
-      && next.every((id, i) => id === this.state.selection[i]);
-    if (same) return;
-    this.set({ selection: next, selectionNodes: nodes && !additive ? nodes : null });
-  }
-  /**
-   * The nodes the selection refers to.
-   *
-   * Resolving ids against `items` only finds rows on the LOADED PAGE of the CURRENT
-   * collection — and the launcher's rows come from search (which the server scopes to
-   * every readable collection) and from recents (which survive a collection switch).
-   * So every row reached by searching resolved to nothing, and rename / move-to-trash /
-   * copy-link returned silently while `explorer.hasSelection` said there was a
-   * selection. Preferring the nodes the selecting caller already held fixes the whole
-   * class; the `items` lookup stays for callers that only have ids.
-   */
-  selectedNodes() {
-    const held = this.state.selectionNodes;
-    if (held?.length) return held.filter((n) => this.state.selection.includes(n.id));
-    return this.state.items.filter((i) => this.state.selection.includes(i.id));
-  }
-}
 
 /**
- * API keys, for the admin screen that manages them.
+ * The nodes the selection refers to — a pure function of explorer state.
  *
- * Its own service rather than a corner of ExplorerService because it is a different
- * lifetime: keys are read when someone opens Settings and never again, so they should not
- * be part of the state every render of the file list walks over.
+ * It was a method, which meant every caller reached for the service to ask a question about
+ * data it could already see. As a function it can be used two ways without either being a
+ * back door: the explorer QUERY folds it into the view, so the UI is handed the answer; and
+ * an effect that needs it right now computes it from the state it already holds.
  *
- * `minted` holds the one secret a mint returns. It lives here, in memory, and is dropped
- * the moment the admin dismisses it — the server cannot show it again, so the UI is the
- * only place it ever exists, and it should not persist anywhere that outlives the tab.
+ * Resolving ids against `items` only finds rows on the LOADED PAGE of the CURRENT
+ * collection — and the launcher's rows come from search (which the server scopes to every
+ * readable collection) and from recents (which survive a collection switch). So every row
+ * reached by searching resolved to nothing, and rename / move-to-trash / copy-link returned
+ * silently while `explorer.hasSelection` said there was a selection. Preferring the nodes
+ * the selecting caller already held fixes the whole class; the `items` lookup stays for
+ * callers that only have ids.
  */
-export class ApiKeysService {
-  constructor() {
-    this.state = {
-      keys: [], loading: false, loaded: false, error: null, minted: null, busy: null,
-      // The mint form. Held here rather than in the DOM so the section stays a pure
-      // function of state — and so a half-filled form survives a re-render caused by
-      // something else on the settings screen.
-      draft: null,
-    };
-    this.cell = cell(this.state);
-  }
-
-  /** Open the mint form, empty. */
-  startDraft() {
-    this.set({ draft: { name: '', expiresInDays: '', caps: {} }, error: null });
-  }
-  cancelDraft() {
-    this.set({ draft: null });
-  }
-  patchDraft(patch) {
-    if (!this.state.draft) return;
-    this.set({ draft: { ...this.state.draft, ...patch } });
-  }
-
-  /**
-   * Toggle one capability on one collection in the draft.
-   *
-   * `admin` is not treated specially here — it is offered as itself and the server
-   * expands it. Pre-ticking read/write/delete when admin is chosen would suggest they
-   * are separable afterwards, and they are not.
-   */
-  toggleCap(collectionId, capability) {
-    if (!this.state.draft) return;
-    const caps = { ...this.state.draft.caps };
-    const held = new Set(caps[collectionId] || []);
-    if (held.has(capability)) held.delete(capability);
-    else held.add(capability);
-    if (held.size) caps[collectionId] = [...held];
-    else delete caps[collectionId];
-    this.patchDraft({ caps });
-  }
-
-  /** The draft as the API wants it, or null when it would grant nothing. */
-  draftScopes() {
-    const caps = this.state.draft?.caps || {};
-    const scopes = Object.entries(caps)
-      .filter(([, list]) => list.length)
-      .map(([collectionId, capabilities]) => ({ collectionId, capabilities }));
-    return scopes.length ? scopes : null;
-  }
-  observe() {
-    return this.cell;
-  }
-  set(patch) {
-    this.state = { ...this.state, ...patch };
-    this.cell.setValue(this.state);
-  }
-  /** Forget the freshly minted secret. Called on dismiss, and after a copy. */
-  clearMinted() {
-    if (this.state.minted) this.set({ minted: null });
-  }
+export function selectedNodesOf(state) {
+  // Tolerant of a partial state: a view is computed on every emission, including the first
+  // one, and a projection that throws takes the whole query down rather than the field.
+  const selection = state?.selection || [];
+  const held = state?.selectionNodes;
+  if (held?.length) return held.filter((n) => selection.includes(n.id));
+  return (state?.items || []).filter((i) => selection.includes(i.id));
 }
 
-export class SearchClientService {
-  constructor() {
-    this.state = { query: '', mode: 'hybrid', results: [], loading: false, error: null, ran: false, paletteFiles: [], paletteQuery: '', paletteLoading: false, paletteError: null };
-    this.cell = cell(this.state);
-  }
-  observe() {
-    return this.cell;
-  }
-  set(patch) {
-    this.state = { ...this.state, ...patch };
-    this.cell.setValue(this.state);
-  }
-}
+
 
 /**
  * Uploads in flight.
@@ -165,11 +53,19 @@ export class SearchClientService {
 export class TransfersService {
   /** @param {import('./activity.js').ActivityService} [activity] */
   constructor(activity = null) {
-    this.state = { items: [] }; // { id, name, direction, ratio, loaded, total, status, error }
+    this.state = { items: [] }; // { id, name, direction, ratio, loaded, total, status, error, retryable }
     this.cell = cell(this.state);
     this._controllers = new Map();
     this.activity = activity;
     this._tasks = new Map(); // transfer id -> activity task handle
+    // How to run this transfer again. Held here rather than in state because it closes
+    // over the File itself, which is not something a state snapshot should carry.
+    //
+    // It exists because automatic retry cannot cover everything: a lost upload session is
+    // `notFound`, which is correctly classified non-retryable and will never succeed on
+    // its own no matter how many times it is tried. Someone has to decide to start over,
+    // and the alternative is asking the user to find the file and drag it in again.
+    this._retries = new Map();
   }
   observe() {
     return this.cell;
@@ -177,16 +73,62 @@ export class TransfersService {
   #emit() {
     this.cell.setValue(this.state);
   }
-  start(id, name, total, controller) {
+  /**
+   * @param {{retry?: () => Promise<any>}} [opts] how to run this transfer again, if it can be
+   */
+  start(id, name, total, controller, { retry = null } = {}) {
     this._controllers.set(id, controller);
-    this.state = { items: [...this.state.items, { id, name, direction: 'up', ratio: 0, loaded: 0, total, status: 'active', error: null }] };
+    if (retry) this._retries.set(id, retry);
+    this.state = {
+      items: [...this.state.items, {
+        id, name, direction: 'up', ratio: 0, loaded: 0, total, status: 'active', error: null,
+        // Surfaced in state so the tray renders from a snapshot rather than interrogating
+        // the service — it is a fact about the row, like `status`.
+        retryable: !!retry,
+      }],
+    };
     this.#emit();
+    this.#task(id, name, total);
+  }
+
+  #task(id, name, total) {
     const task = this.activity?.start({
       kind: 'transfer', title: `Uploading ${name}`, total: total || null, unit: 'bytes',
       onCancel: () => this.cancel(id),
     });
     if (task) this._tasks.set(id, task);
   }
+
+  /**
+   * Run a failed transfer again, in place.
+   *
+   * The same row rather than a new one: a retry is another attempt at the thing the user
+   * already asked for, and a tray that grew an entry per attempt would report one upload
+   * as four.
+   */
+  retry(id) {
+    const again = this._retries.get(id);
+    if (!again) return null;
+    const item = this.state.items.find((t) => t.id === id);
+    if (!item || item.status === 'active') return null;
+    return again();
+  }
+
+  /** Put an existing row back into flight — see `retry`. */
+  restart(id, controller) {
+    this._controllers.set(id, controller);
+    const item = this.state.items.find((t) => t.id === id);
+    this.state = {
+      items: this.state.items.map((t) => (t.id === id
+        ? { ...t, status: 'active', error: null, ratio: 0, loaded: 0 }
+        : t)),
+    };
+    this.#emit();
+    // A fresh activity task: the previous one already ended as failed, and reporting
+    // progress into a finished task would leave the panel showing a failure that is
+    // actively being retried.
+    this.#task(id, item?.name || 'file', item?.total || null);
+  }
   progress(id, { loaded, total, ratio }) {
     this.state = { items: this.state.items.map((t) => (t.id === id ? { ...t, loaded, total, ratio } : t)) };
     this.#emit();
@@ -211,10 +153,64 @@ export class TransfersService {
   }
   dismiss(id) {
     this.state = { items: this.state.items.filter((t) => t.id !== id) };
+    this._retries.delete(id);
     this.#emit();
   }
   clearDone() {
-    this.state = { items: this.state.items.filter((t) => t.status === 'active') };
+    const kept = this.state.items.filter((t) => t.status === 'active');
+    const keptIds = new Set(kept.map((t) => t.id));
+    // Drop the retry thunks of the rows that just left, so a dismissed upload does not
+    // hold its File alive for the rest of the session.
+    for (const id of [...this._retries.keys()]) if (!keptIds.has(id)) this._retries.delete(id);
+    this.state = { items: kept };
     this.#emit();
   }
 }
+
+
+/**
+ * The API-key draft as the API wants it, or null when it would grant nothing.
+ *
+ * A pure function rather than a method, for the same reason as `selectedNodesOf`: it is a
+ * derivation, so it belongs to the view that shows it and to the action that submits it,
+ * not to the resource that happens to hold the draft.
+ */
+export function draftScopesOf(state) {
+  const caps = state?.draft?.caps || {};
+  const scopes = Object.entries(caps)
+    .filter(([, list]) => list.length)
+    .map(([collectionId, capabilities]) => ({ collectionId, capabilities }));
+  return scopes.length ? scopes : null;
+}
+
+
+/**
+ * The collection switcher's menu, derived from what the explorer knows.
+ *
+ * A pure function for the same reason as `selectedNodesOf`: it answers a question about
+ * state, so it belongs to the view that shows it. It used to be a closure hung on `app` by
+ * `registerCommands` — reachable only through that one field, and impossible to see from
+ * the component that rendered it.
+ *
+ * Items carry `actions`, like every other menu item; see ui/activate.js.
+ *
+ * @param {object} state explorer state
+ * @param {(id?: string) => object} switchTo builds the action for picking a collection
+ * @param {() => object} create builds the action for making a new one
+ */
+export function collectionMenuOf(state, switchTo, create) {
+  // No fallback: this only decides which row gets a tick, and with nothing open the answer
+  // is that none of them do. `|| 'default'` ticked a collection the user had not chosen,
+  // and on a drive with one actually called "default", the wrong one.
+  const current = state?.collectionId;
+  const items = (state?.collections || []).map((c) => ({
+    label: c.name || c.id,
+    icon: c.id === current ? 'check' : 'files',
+    actions: [switchTo(c.id)],
+  }));
+  if (state?.canCreateCollection) {
+    if (items.length) items.push({ sep: true });
+    items.push({ label: 'New collection…', icon: 'plus', actions: [create()] });
+  }
+  return items;
+}

package/packages/web/src/bl/social.js

@@ -8,7 +8,9 @@
 import { cell } from '../runtime.js';
 
 export class SocialService {
-  constructor(platform) {
+  constructor(platform, offline = null) {
+    // How a comment or tag written while disconnected reaches the server later.
+    this.offline = offline;
     this.platform = platform;
     this.api = platform.api;
     this.state = {

package/packages/web/src/bl/state.js

@@ -0,0 +1,144 @@
+// The drive's own state, as named slices.
+//
+// These were classes: an `ExplorerService`, a `SearchClientService`, an `ApiKeysService`,
+// each holding a `state` field, a `cell`, and a `set` that wrote both. Nothing else. A
+// service should cover something complex and offer it through a narrow door — these
+// covered an object.
+//
+// Two things came of that shape and both are gone with it.
+//
+// TWO DOORS. Actions read `.state` and queries read `.cell`, and the two are only equal by
+// habit: most services wrote `this.state = {...}; this.cell.setValue(this.state)`, but not
+// all did, and `settings` still has a cell holding `effective()` and no `state` field at
+// all. A slice has one value and one way to read it.
+//
+// LOGIC IN THE HOLDER. `toggleCap` computed a capability set inside the service while an
+// action stood in front of it forwarding two arguments — and dropped one of them, which is
+// how a minted key came to be rejected by the server. Arithmetic over state belongs to the
+// action that decides to change it; the slice only holds.
+//
+// Each slice is still its OWN provider, so `static deps = ['explorer']` keeps meaning what
+// it says. A single `appState` covering everything would put the whole drive back behind
+// one lease, which is what naming the resources individually was for.
+
+import { cell } from '../runtime.js';
+
+/**
+ * One named piece of the drive's state.
+ *
+ * `set` merges, because every caller was already merging and doing it here removes the
+ * chance of a caller replacing a slice by forgetting to spread it. `replace` exists for
+ * the cases that genuinely mean "all of it" — a fresh panel stack, an emptied list.
+ *
+ * @param {object} initial
+ */
+export function slice(initial = {}) {
+  const held = cell(initial);
+  return {
+    /** The cell, for a query to watch. */
+    observe: () => held,
+    /** The value, for an action about to decide something from it. */
+    get: () => held.getValue(),
+    /** Merge a patch in. A new object every time — a cell compares with Object.is. */
+    set: (patch) => held.setValue({ ...held.getValue(), ...patch }),
+    /** Replace it outright, for when a patch would be a lie. */
+    replace: (next) => held.setValue(next),
+  };
+}
+
+/** Items, selection, the open collection, and the gate. */
+export const explorerState = (settings) => slice({
+  items: [], loading: false, error: null,
+  selection: [], sort: settings.get('explorer.sort'), order: settings.get('explorer.sortOrder'),
+  // No collection until one is chosen or created. `gate` is 'create' | 'choose' | null —
+  // when set, it is the ONLY thing the workbench shows, because every request needs a
+  // collection and there is nothing sensible to render without one.
+  collectionId: null, collections: [], canCreateCollection: false, gate: null,
+  // `stats` is the whole collection; `items` is the page on screen. Keeping both is what
+  // lets the UI say "500 of 3,006" instead of quietly claiming 500.
+  stats: null, usage: null, nextCursor: null, loadingMore: false, trash: null,
+});
+
+/** Query text, results, and the palette's separate file list. */
+export const searchState = () => slice({
+  query: '', mode: 'hybrid', results: [], loading: false, error: null, ran: false,
+  paletteFiles: [], paletteQuery: '', paletteLoading: false, paletteError: null,
+});
+
+/**
+ * The admin API-key list.
+ *
+ * `minted` holds the one secret a mint returns. It lives here, in memory, and is dropped
+ * the moment the admin dismisses it — the server cannot show it again, so the UI is the
+ * only place it ever exists and it must not outlive the tab.
+ *
+ * `draft` is the mint form. Held in state rather than in the DOM so the section stays a
+ * pure function of state, and so a half-filled form survives a re-render caused by
+ * something else on the settings screen.
+ */
+export const apiKeysState = () => slice({
+  keys: [], loading: false, loaded: false, error: null, minted: null, busy: null, draft: null,
+});
+
+/**
+ * What the UI is in the middle of doing — a keybinding mid-capture, text typed into a
+ * dialog that has not been submitted, the boxes ticked in a plugin review.
+ *
+ * None of it is drive state; all of it decides what is on screen, which is what makes it
+ * engine state. Keyed by component, so `set` here replaces one key rather than merging a
+ * patch — see SetViewStateAction.
+ */
+export const viewState = () => slice({});
+
+/**
+ * The shell's transient overlays: the command palette, a modal dialog, the right-click
+ * menu, and the plugin popup panel.
+ *
+ * Four things that are independent of the panel stack and of each other, which is why they
+ * were split out of the workbench in the first place. What they are NOT is complex enough
+ * to need a service — the class was four setters and a `wrapIndex`, with an action standing
+ * in front of each one. The wrapping now lives in the action that moves a cursor, which is
+ * where it was needed: MovePaletteAction lost the count argument once already, precisely
+ * because deciding and writing were on opposite sides of a forwarding layer.
+ */
+export const overlayState = () => slice({
+  palette: null, // { mode: 'commands'|'files', query, index } when open
+  dialog: null,
+  contextMenu: null,
+  pluginPanel: null,
+});
+
+/**
+ * The shell itself: which activity is showing, and the launcher's own cursor.
+ *
+ * The panel stack is NOT here — that is NavigationService, which stays a service because it
+ * mirrors the stack into browser history and persists recents, neither of which a state bag
+ * can do.
+ */
+export const workbenchState = () => slice({
+  activity: 'home', // home (stack) | plugins | settings
+  sidebarVisible: true,
+  launch: { query: '', index: 0 },
+  searchModal: false, // the double-shift modal search overlay
+  // Phone chrome: which bottom sheet is up, if any ('status' | 'more'). A phone has no room
+  // for a permanent status bar or a left rail, so both fold into a sheet pulled up on demand.
+  sheet: null,
+  infoPanel: false,
+});
+
+/** Wrap a list cursor by `delta` within `[0, count)` — the palette and the launcher share it. */
+export function wrapIndex(index, delta, count) {
+  return (index + delta + count) % count;
+}
+
+/**
+ * What the open collection's key is doing.
+ *
+ * Rotation is long-running and lives on the server, so this is a local view of it kept in
+ * step by polling while the settings screen is open — see `RotationQuery`. It is state
+ * rather than a fetch-per-render because two things read it (the progress line and whether
+ * Start is offered) and they must not disagree.
+ */
+export const rotationState = () => slice({
+  collectionId: null, rotation: null, estimate: null, loading: false, error: null, busy: false,
+});

package/packages/web/src/bl/status.js

@@ -0,0 +1,96 @@
+// What the drive is doing and how full it is — one answer, for every surface that says so.
+//
+// This lived in the status bar and was imported from there by the phone chrome, which is
+// how it was already admitting to being shared: two shells rendering the same facts in
+// different shapes. It is a derivation over four resources, so it belongs here, and it is
+// reached as the `statusFacts` query rather than recomputed per render.
+//
+// The reason it has to be derived ONCE rather than twice is on the record: the phone bar
+// rendered `collectionId` raw and showed an opaque `col_…` where the desktop bar showed the
+// collection's name — the same fact, said two ways, because each surface worked it out.
+
+/**
+ * The facts every shell reports.
+ *
+ * @param {{ex: object, tr: object, act: object, off: object}} slices
+ */
+export function statusFactsOf({ ex = {}, tr = {}, act = {}, off = {} } = {}) {
+  const items = ex.items || [];
+  const tasks = act.tasks || [];
+  return {
+    // `null` with nothing open — `collectionLabelOf` renders that as "no collection". The
+    // old fallback made the bar name a collection that may not exist, on a drive where the
+    // user had not yet chosen one.
+    collectionId: ex.collectionId ?? null,
+    // What to CALL it, so the phone shell and the desktop bar cannot end up saying
+    // different things.
+    collectionLabel: collectionLabelOf(ex),
+    // The COLLECTION's totals when the server could give them, not the page's. Summing what
+    // happens to be loaded reports a 3,000-file drive as 500 files — a wrong number, not a
+    // rounded one. Falls back to the page only when the server didn't say.
+    totalItems: ex.stats?.items ?? items.length,
+    // Whether that total is the COLLECTION's or just the page we happen to hold. With more
+    // pages waiting, the page length is a floor, not a total, and must read as one.
+    totalKnown: ex.stats?.items != null,
+    totalBytes: ex.stats?.bytes ?? items.reduce((n, i) => n + (i.size || 0), 0),
+    shown: items.length,
+    partial: !!ex.nextCursor,
+    usage: ex.usage ?? null,
+    usageLevel: usageLevelOf(ex.usage),
+    uploading: (tr.items || []).filter((t) => t.status === 'active'),
+    running: tasks.filter((t) => t.status === 'running'),
+    issues: act.issues || [],
+    off: { online: true, pins: [], queued: 0, syncing: false, ...off },
+  };
+}
+
+/** The open collection's name, or the plainest true thing when there isn't one. */
+export function collectionLabelOf(ex) {
+  if (!ex?.collectionId) return 'no collection';
+  const match = (ex.collections || []).find((c) => c.id === ex.collectionId);
+  return match?.name || ex.collectionId;
+}
+
+/**
+ * How worried to be about space, or '' when there is nothing to say.
+ *
+ * A filesystem or NAS can answer exactly, and that is where it matters: a disk fills up and
+ * every upload starts failing with no warning that anything was coming. An object store has
+ * no equivalent number, so this answers '' and the meter is not drawn at all rather than
+ * being drawn meaninglessly.
+ *
+ * The thresholds are a judgement about when someone still has time to act, which is why
+ * they are here and not in whichever bar happens to be on screen.
+ */
+export function usageLevelOf(usage) {
+  if (!usage?.total) return '';
+  const free = usage.available / usage.total;
+  return free < 0.05 ? 'critical' : free < 0.1 ? 'low' : '';
+}
+
+/**
+ * The one thing worth saying about the drive right now, most urgent first.
+ *
+ * The phone has room for a single glyph, so something has to decide what outranks what:
+ * being offline beats a standing problem, a standing problem beats work in progress, and
+ * anything beats running low on space. That ordering is a claim about which condition a
+ * person most needs to know, which makes it a decision rather than a rendering.
+ *
+ * Answers a KIND, not an icon. Which glyph draws a kind is the shell's business.
+ */
+export function driveConditionOf(facts) {
+  const f = facts || {};
+  if (!f.off?.online) return { kind: 'offline', label: 'Offline' };
+  if (f.issues?.length) {
+    return {
+      kind: 'issues',
+      label: `${f.issues.length} need${f.issues.length === 1 ? 's' : ''} attention`,
+      count: f.issues.length,
+    };
+  }
+  if (f.running?.length || f.uploading?.length || f.off?.syncing) {
+    return { kind: 'working', label: 'Working…', count: (f.running?.length || 0) + (f.uploading?.length || 0) };
+  }
+  if (f.usageLevel) return { kind: 'lowSpace', label: 'Low on space' };
+  return { kind: 'idle', label: 'Status' };
+}