primitive-admin 1.0.62 → 1.0.64

package/dist/src/commands/sync.d.ts

@@ -4,7 +4,11 @@ import { type OperationFormHints } from "../lib/toml-database-config.js";
 import { type FieldForm } from "../lib/toml-native-form.js";
 import { type PushMode } from "../lib/config-payload.js";
 import { type ConfigObjectSurface, type ConfigTable } from "../lib/generated-config-surfaces.js";
+import { type PromptKind } from "../lib/generated-config-surfaces.js";
+import { type AgentFunctionFacts } from "../lib/generated-config-surfaces.js";
+import { type DocumentSchemaResolution } from "../lib/function-document-types.js";
 import { type PresenceOutcome, type TestBlockType } from "../lib/sync-resource-types.js";
+export { resolveSlugCollisions, slugifyTestCaseName, testCaseFileBasenames, } from "../lib/test-case-file-names.js";
 import type { SyncState } from "../types/index.js";
 import { type SyncSelection } from "../lib/sync-selectors.js";
 /**
@@ -334,6 +338,20 @@ export declare function validateVarsFile(parsedVars: Record<string, unknown>, op
  * edit — reported as a conflict instead. `force` skips the conflict guard,
  * matching `config push --force` for every other entity.
  *
+ * A var only the SERVER moved is the other half of the same comparison, and it
+ * is reported rather than skipped (issue #3714). Its local value still equals
+ * the baseline, so there is nothing to push and no conflict — but the skip that
+ * follows from "local is unchanged" used to be taken before the snapshot was
+ * consulted at all, so the push said nothing about a var edited in the Admin
+ * Console and counted it among the skipped-unchanged. The `drifted[]` keys are
+ * what every other synced type reaches through `classifyPushChange` →
+ * `server-drifted`: the caller prints `DRIFT var: <key>` under "Server drift —
+ * not pushed", writes nothing, and leaves the exit code alone. A baseline key
+ * the snapshot no longer holds at all is the same one-sided move (the server
+ * deleted the row; the local file stands still) and is reported the same way.
+ * `--force` is the resolution that keeps the local value, `config pull` the one
+ * that takes the server's.
+ *
  * Pure and side-effect-free (the caller owns the API calls and sync-state
  * updates) so the guard is unit-testable without a live server. Assumes
  * `parsedVars` has already passed `validateVarsFile` (values are strings). The
@@ -363,6 +381,11 @@ export declare function planVarsPush(parsedVars: Record<string, string>, baselin
         serverModifiedAt: string;
         localModifiedAt: string;
     }>;
+    /** Keys the SERVER alone moved — reported, never written (issue #3714). */
+    drifted: Array<{
+        key: string;
+        serverModifiedAt: string;
+    }>;
     skippedCount: number;
 };
 /**
@@ -661,6 +684,21 @@ export declare function serializeBlobBucket(bucket: any, logger?: (message: stri
  * drift.
  */
 export declare function buildBlobBucketUpdatePayload(bucket: any): any;
+/**
+ * #3201's post-create status patch is RETIRED — #3799 (DSO-3799-005).
+ *
+ * `status` was update-only, so `POST /prompts` and `POST /prompts/:id/configs`
+ * both assigned `active` whatever the body said, and an authored
+ * `status = "archived"` needed a follow-up PATCH ordered after the activation of
+ * the entry the file marks live. Both create paths honor the key now
+ * (`writableOn: BOTH`, validated by one rule on all three paths), so the entry
+ * lands retired on its own create: the same end state, two fewer calls per
+ * retired config, and no window in which the server holds a status the file
+ * never asked for. That window is what made a pulled tree unpushable into a
+ * fresh environment once an agent's schemas are checked against each
+ * non-archived config's provider — the check fired on the transient active
+ * state.
+ */
 /**
  * Which `[[configs]]` entry a prompt file marks as live (issue #2645).
  *
@@ -766,6 +804,12 @@ export declare function buildPromptCreatePayload(key: string, tomlData: any): Re
  * `seededConfigName` is what the server called it — read from the create
  * response rather than assumed, so a handler that one day honors the name
  * produces no needless PATCH.
+ *
+ * #3201 — the entry's `status` was deferred the OTHER way, to a patch after the
+ * activation, because the create pointed the prompt's `activeConfigId` at a
+ * config it had forced live. #3799 (DSO-3799-005) — the create carries the
+ * entry's `status` itself now, so there is no deferral either way and this patch
+ * is the two fields `POST /prompts` cannot express, nothing more.
  */
 export declare function seededOnlyPromptConfigFields(firstConfig: any, seededConfigName?: string): Record<string, any> | null;
 /**
@@ -851,21 +895,175 @@ export interface ConfigFileValidationError {
     messages: string[];
 }
 /**
- * Every per-entity config file whose TOML `config push` would refuse (#2880
- * criterion 1, symmetry).
+ * `config push`'s preflight — every check the authored files decide on their
+ * own, run before the FIRST mutating call (#976 fix A, #3320, #3375).
+ *
+ * The block below was inline inside the push command's `.action()` callback
+ * until #3375 lifted it here unchanged. It had to become an exported symbol
+ * for the registry's promise to be checkable at all: a rule declared
+ * `preflight` says it runs before `config push` mutates anything, and
+ * `src/config-surface/preflight-reachability.ts` resolves that claim
+ * statically from the declared `<module>#<export>` against exactly this entry
+ * point. With the preflight anonymous, "reached from the preflight" had
+ * nothing to resolve against, and the stage string was satisfied by typing it.
+ *
+ * Its boundary is therefore precise and load-bearing: this function is what
+ * contributes to `preflightValidationErrors` and aborts. The advisory reads
+ * that follow the abort in the action — the remote vars snapshot and both caps
+ * — stay there and are declared `apply`, because the server is what enforces
+ * them (`intent` §Non-goals, "Emptying the apply stage").
+ *
+ * A network call inside a preflight is not disqualifying: `listIntegrations`
+ * was already here, answering "will this `integration:` grant have a target?"
+ * against the live listing merged with the tree, and falling back to the tree
+ * alone when the listing cannot be fetched.
+ *
+ * `input` names what the block used to close over. `client` is narrowed to the
+ * one method it calls, so an apply call cannot drift in here later without
+ * that being a visible change to this signature.
+ */
+export declare function runConfigPushPreflight(input: {
+    configDir: string;
+    resolvedAppId: string;
+    pushSelection: SyncSelection | null;
+    syncState: SyncState | null;
+    force: boolean;
+    isCrossAppPush: boolean;
+    client: Pick<ApiClient, "listIntegrations" | "listFunctions">;
+}): Promise<{
+    parsedVars: Record<string, unknown> | null;
+}>;
+export declare function promptKindFileErrors(filePath: string, tomlData: any): string[];
+/**
+ * The functions an agent's references are checked against at push — #3798,
+ * DSO-3798-002.
+ *
+ * `config push` applies prompts, then (for agents) the server functions leg,
+ * so a reference may be satisfied by a function that is live already or by one
+ * this push creates. What the push BELIEVES is therefore the live listing
+ * overlaid by the function files this push SELECTS (`--only`, every file when
+ * unscoped): a selected file's schemas are what the server will hold after the
+ * push, so it wins over the live row. An UNSELECTED file is not read at all —
+ * its edits will not be applied, and a function only it declares will not
+ * exist afterwards.
+ *
+ * `live` is `null` when the listing could not be fetched: the selected files
+ * still count, and `liveListed` lets the refusal say why every other reference
+ * could not be confirmed. A live row that is archived is a tombstone, not a
+ * function; an inactive one is accepted (the turn engine re-checks
+ * availability on every call).
+ */
+export declare function agentFunctionFactsForPush(input: {
+    configDir: string;
+    pushSelection: SyncSelection | null;
+    live: ReadonlyArray<Record<string, unknown>> | null;
+}): {
+    facts: AgentFunctionFacts;
+    liveListed: boolean;
+};
+/**
+ * The function half of an agent's declaration — #3798: every tool, turn
+ * context and history function that the functions this push believes
+ * (`agentFunctionFactsForPush`) do not have, and every tool function lacking an
+ * input or output schema. The same `resolveAgentDeclaration` the admin routes
+ * run; only its function refusals are reported here, because the collector
+ * (`promptKindFileErrors`) already reported the file-decidable ones.
+ */
+export declare function promptAgentFunctionErrors(filePath: string, tomlData: any, known: {
+    facts: AgentFunctionFacts;
+    liveListed: boolean;
+}): string[];
+/**
+ * The order `config push` applies prompt files in — #3798. An agent names
+ * server functions that must exist when it is created, and the push applies
+ * prompts before functions, so agent files go AFTER the server-functions leg;
+ * every other file keeps its place. A file that does not parse stays first, so
+ * the leg reports it where it always has.
+ */
+export declare function partitionPromptFilesForPush(promptsDir: string, files: readonly string[]): {
+    beforeFunctions: string[];
+    afterFunctions: string[];
+};
+/**
+ * Every `prompts/<key>.tests/*.toml` sidecar whose prompt is an agent — #3798
+ * (§D1: prompt test cases are refused for the kind in v1). The admin test-case
+ * routes refuse the same case with `AGENT_TEST_CASE_NOT_SUPPORTED`; this says
+ * so before anything is applied.
+ */
+export declare function promptAgentSidecarErrors(configDir: string): string[];
+/**
+ * The immutable-`kind` refusal for a prompt update the comparison gate did not
+ * decide — #3626, CR3626-001.
+ *
+ * `kind` is create-only (D3626-008), and the gate refuses a change to it on
+ * every path that compares the two sides. Two update paths do not compare: a
+ * prompt whose DETAIL read failed falls back to the manifest byte-hash gate,
+ * which `--force` writes straight through, and a prompt ADOPTED after a
+ * create's 409 is re-issued as an update without a comparison at all. Both
+ * would otherwise PATCH the file's schemas, access rule and metadata onto a
+ * row of the other kind, and only then have its configs refused against the
+ * kind the update cannot change.
+ *
+ * Returns the gate's own outcome shape, so `recordDeclined` prints the same
+ * two values and the same remedy — create the prompt under a new key.
  *
- * One collector, two commands. Push aborts on the messages before issuing a
- * request; `config diff` renders them as their own rows, because the failure
- * this closes is a file diff calls Synced and push then rejects — the state the
- * issue's reporter hit after #2803 retired `[prompt].status`, where a local key
- * with no server counterpart is invisible to a comparison and fatal to a push.
+ * `null` when the kinds agree and when the server's kind is simply not KNOWN:
+ * a push that could not read live state at all has nothing to compare, and
+ * that path's contract (`decideDegradedPush`, #2880) is already "decline
+ * unless the operator forces it", stated for every field at once.
+ */
+export declare function promptKindImmutableOutcome(storedKind: PromptKind | undefined, localDoc: any): Extract<PushGateOutcome, {
+    action: "immutable";
+}> | null;
+/**
+ * The one deprecation notice a prompt file using the FLAT chat spelling earns
+ * — #3626 §4, beside the `celContextAccess` notice's precedent.
  *
- * Three checks, all definition-driven: the document's table shape, keys no
- * definition declares (retired keys among them), and — since #2880 — values
- * whose spelling is not the declared type. A file that does not parse is left
- * to the per-type loop that reads it, which names the parse error itself.
+ * Advisory: the push continues and the keys are applied. `null` when the file
+ * is already written in the grouped spelling, so a migrated tree is silent.
  */
+export declare function promptFlatChatKeyWarning(filePath: string, tomlData: any): string | null;
 export declare function collectConfigFileValidationErrors(configDir: string): ConfigFileValidationError[];
+/**
+ * Every `functions/<key>.toml` whose file-decidable errors `config push` would
+ * refuse (#3320).
+ *
+ * A second collector rather than a branch inside
+ * `collectConfigFileValidationErrors`, and deliberately so: push calls that one
+ * UNBOUNDED over the whole tree, which is right for the checks it runs (a
+ * mistyped key anywhere means the tree is not pushable) and wrong for these — a
+ * `config push --only webhook/<key>` must not be blocked by a broken function
+ * the operator did not select (#2645). The push path therefore runs these
+ * inside its own `selectFiles`-bounded function loop, and `config diff`, which
+ * compares the whole tree by construction, runs them from here.
+ *
+ * A file that does not parse is skipped: the per-type loop that reads it names
+ * the parse error itself, and reporting it twice helps nobody.
+ */
+export declare function collectFunctionTomlValidationErrors(configDir: string): ConfigFileValidationError[];
+/**
+ * The retired runtime keys every `functions/*.toml` in the tree still carries
+ * — #3482, the warning half of the collector above.
+ *
+ * Separate from the errors because it IS separate: a file carrying one of
+ * these pushes, with every other key applied, so it is not a row `config diff`
+ * calls invalid. It is a line an author reads on stderr from both commands, so
+ * the two keep reading identically (the #2880 symmetry the errors collector
+ * exists for, applied to advice rather than refusals).
+ */
+export declare function collectFunctionTomlIgnoredKeyWarnings(configDir: string): string[];
+/**
+ * The collectors' rows, one per diff row (#2880 symmetry, #3320).
+ *
+ * Two collectors reach the same function file — the definition-driven one
+ * every per-entity type runs, and the function preflight — and a file can
+ * break both at once (a mistyped `entrty`, which then leaves no `entry`).
+ * Push reports every message from both, so an overlay that let one row's
+ * messages REPLACE the other's would drop a diagnostic push prints, which is
+ * exactly the asymmetry #2880 forbids. Merging by row keeps the two commands
+ * reading identically.
+ */
+export declare function mergeConfigFileValidationErrors(collected: ConfigFileValidationError[]): ConfigFileValidationError[];
 /**
  * Every `<key>.tests/*.toml` sidecar under a config directory.
  *
@@ -939,6 +1137,15 @@ export declare function workflowPushSendsUpdate(configDir: string, key: string,
  *
  * Returns `null` when the name is present.
  */
+/**
+ * The preflight error a project's document schema contributes, or `null` —
+ * #3719.
+ *
+ * Only a `refusal` counts: a unique constraint on a stringset field, which no
+ * writer can key consistently, so the push stops before any mutation. Every
+ * other unusable-schema case stays the apply loop's warning (D3455-004).
+ */
+export declare function documentSchemaPreflightError(resolution: DocumentSchemaResolution): string | null;
 export declare function workflowUpdateNameError(filePath: string, workflow: any): string | null;
 export declare function serializeWorkflow(workflow: any, draft: any, configs: any[], logger?: (message: string) => void): string;
 export declare function serializeDatabaseType(typeConfig: any, operations: any[], ruleSetIdToName: Map<string, string>, options?: {
@@ -1141,6 +1348,31 @@ export declare function diffProjectedRecords(local: Record<string, any>, remote:
     local: any;
     server: any;
 }>;
+/**
+ * The paths at which two projected records disagree, named the way the FILE
+ * spells them (#3267) — what a `config diff` Modified row prints.
+ *
+ * `diffProjectedRecords` answers at the granularity of the projection, and
+ * for a database type that is too coarse to act on: the 27 operations arrive
+ * as one `operations` extra, the whole `[models.*]` tree as one `schema`
+ * string. A row that read Modified for a reason the operator could not see —
+ * an empty params set spelled two ways, an operation block the file declares
+ * twice — was undiagnosable from the CLI. So this walks INTO each differing
+ * field: a keyed child collection (`spec.childKeys`) is compared row by row
+ * and named `operations["getInstitution"].params`, with a row only one side
+ * has or that the file repeats named as such; a TOML-string field
+ * (`spec.tomlFields`) is parsed on both sides and named by the path inside it
+ * (`schema (models.Institution.fields.name.required)`); everything else is
+ * walked as a value to its first differing leaf.
+ *
+ * Paths come back in projected-key order, keyed rows in key order, so the
+ * list is stable across runs, and every leaf is its own entry — a schema
+ * that differs in seven model fields is seven paths, so the caller's "+N
+ * more" cap counts them the way it counts operations. A value the walk
+ * cannot descend into (an array of a different length, a scalar against an
+ * object) is named at the level it stopped.
+ */
+export declare function describeProjectedDifferences(spec: Pick<ConfigDiffSpec, "childKeys" | "tomlFields">, local: Record<string, any>, remote: Record<string, any>): string[];
 /**
  * The differing fields the definition says an UPDATE does not accept (#2731 B8).
  *
@@ -1171,6 +1403,19 @@ export declare function classifyPushChange(input: {
     localHash: string;
     remoteHash: string;
     baselineHash?: string;
+    /**
+     * The server record has NOT been written since the last sync (#3317).
+     *
+     * Its own `modifiedAt` is what says so, and that is evidence no hash can
+     * contradict: a record nothing has written cannot have drifted, so the local
+     * file is the only side that can have moved. A baseline hash disagreeing
+     * with the current remote projection then says something about the BASELINE
+     * — recorded by a CLI whose projection of the same record differed — and not
+     * about the server. Left false by callers whose row timestamp does not cover
+     * everything the projection compares; `decidePushForConfig` owns that
+     * judgement.
+     */
+    serverUnchangedSinceSync?: boolean;
     legacy?: {
         localBytesMatchStoredContentHash?: boolean;
         liveModifiedAtMatchesStored?: boolean;
@@ -1231,6 +1476,20 @@ export interface ConfigDiffSpec {
      * that there is nothing to do.
      */
     unmanaged?(doc: any): string[];
+    /**
+     * The projected extras that are KEYED child collections, by the key each
+     * row carries (#3267) — a database type's `operations` by `name`. The
+     * comparison already sorts these by key (`byKey`); this is what lets a
+     * difference in one be NAMED as the row and the sub-field it is in, rather
+     * than as the whole collection.
+     */
+    childKeys?: Record<string, string>;
+    /**
+     * The projected extras that are TOML documents held as strings (#3267) —
+     * a database type's `[models.*]` `schema`. Named as the path inside the
+     * document that differs, when both sides parse.
+     */
+    tomlFields?: string[];
     /** Whether the entity carries a rule-set reference needing resolution. */
     ruleSetRef?: boolean;
     /** How the type names itself in the rule-set resolution message. */
@@ -1353,6 +1612,13 @@ export interface PushBaselineEntry {
     modifiedAt?: string;
     contentHash?: string;
     semanticHash?: string;
+    /**
+     * The version the manifest last saw active, for a versioned type (#3317).
+     * Read only beside `serverModifiedAtCoversProjection`: a recorded pointer
+     * that is not the live one denies the timestamp's claim that the server
+     * stood still.
+     */
+    activeConfigId?: string;
 }
 /**
  * `config push`'s change decision for one configuration file (#2731 B1/B3/B4/B8).
@@ -1432,6 +1698,33 @@ export declare function decidePushForConfig(input: {
      */
     localExtra?: any;
     force?: boolean;
+    /**
+     * Whether the live record's `modifiedAt` covers EVERYTHING this type's
+     * projection compares (#3317).
+     *
+     * Opt-in, because it is a claim about the data model rather than about this
+     * push. A server function's header row carries its fields and the
+     * `activeConfigId` pointer, and a version is immutable, so any change to
+     * what the comparison reads moves that one timestamp — an equal timestamp
+     * therefore PROVES the server stood still, and a baseline hash that
+     * disagrees is stale rather than evidence of drift (the reporter's conflict,
+     * printed over two identical timestamps).
+     *
+     * A database type's is the counter-example and the reason this is not the
+     * default: its operations and subscriptions are rows of their own, so an
+     * out-of-band edit to one changes the projection while the type's own
+     * `modifiedAt` stands still. Claiming coverage there would turn a real
+     * server change into a silent overwrite.
+     *
+     * The timestamp is trusted only alongside the version pointer: when the
+     * manifest recorded an `activeConfigId`, the live record must still point at
+     * it. The baseline is written from a header refetched AFTER the push, and a
+     * concurrent activation landing in that window leaves the manifest carrying
+     * the other operator's timestamp beside the version this push activated —
+     * two timestamps that agree about a server that moved to a version the local
+     * file never saw. The pointer is what moved, so it is what settles it.
+     */
+    serverModifiedAtCoversProjection?: boolean;
     /**
      * Whether this type's push path ADOPTS an existing object by key (#2909).
      *
@@ -1699,7 +1992,7 @@ export declare function configSemanticHash(label: string, filePath: string, maps
 /**
  * The sync state `config push` writes into (#2731 B6, closing #2374).
  *
- * `loadSyncState` answers `null` for an absent `.primitive-sync.json`, and
+ * `loadSyncState` answers `null` for an absent sync-state baseline, and
  * every per-entity state write in the push loops is guarded by `if (syncState)`
  * — so a first push created every resource and recorded none of them. The next
  * push then re-entered the create path for everything and depended on 409
@@ -1806,17 +2099,6 @@ export declare function unselectedRuleSetIds(params: {
     /** The `ruleSet.name` a file declares — the name references use. */
     nameForFile: (file: string) => string | undefined;
 }): Map<string, string>;
-export declare function slugifyTestCaseName(name: string): string;
-/**
- * The name to use for `slug`, given the names already taken.
- *
- * `occupy` decides what "already taken" means, and `usedSlugs` holds names in
- * that form (#2896): a file name is occupied CASE-INSENSITIVELY on the
- * filesystems most of these trees live on, so `Foo` and `foo` are one file even
- * though they are two strings. The returned name keeps its own casing — only
- * the occupancy check is normalized.
- */
-export declare function resolveSlugCollisions(slug: string, usedSlugs: Set<string>, occupy?: (name: string) => string): string;
 export declare function getTestsDir(configDir: string, blockType: string, blockKey: string): string;
 export interface TestCaseLookupMaps {
     configIdToName: Map<string, string>;
@@ -1891,6 +2173,91 @@ selects?: (name: string) => boolean): Promise<{
     /** Names the server listed, empty when the listing failed. */
     serverKeys: string[];
 }>;
+/**
+ * The manifest row `config push` records for a function it just pushed
+ * (#3317), and whether the server had already moved past that push.
+ *
+ * The header is refetched AFTER the version push, so the row's `modifiedAt`
+ * is the live timestamp — but the version pointer and the envelope are the
+ * push's own: the manifest names what THIS run activated, not whatever the
+ * refetch happened to find. A concurrent activation landing between the push
+ * and the refetch is exactly the case those two must not be conflated in:
+ * recording the refetched pointer would make the other operator's version the
+ * baseline the local file is then read as a plain edit of, and the next push
+ * would roll it back without `--force`. Recording the pushed pointer beside
+ * the live timestamp is what `decidePushForConfig` reads as "the pointer
+ * moved" — a refusal, until the operator pulls or forces.
+ *
+ * `movedTo` names the version the refetched header points at when it is not
+ * the pushed one, so the caller can say so at the moment it is known rather
+ * than leaving it for the next push to report.
+ */
+export declare function pushedFunctionBaseline(input: {
+    functionId: string;
+    /** The header refetched after the push, or the pre-push listing row. */
+    refreshed: any;
+    existingModifiedAt?: string;
+    contentHash: string;
+    /** The version the push activated (created, or the matched no-op). */
+    pushedVersion: any;
+    envelopeHash: string;
+    sources: string[];
+    spec: ConfigDiffSpec;
+    maps: ConfigDiffMaps;
+}): {
+    entity: {
+        id: string;
+        modifiedAt: string;
+        contentHash: string;
+        semanticHash?: string;
+        envelopeHash: string;
+        activeConfigId?: string;
+        sources: string[];
+    };
+    movedTo: string | null;
+};
+/**
+ * Pull server-side `ServerFunction` rows into `functions/` (#3179).
+ *
+ * Two things make this different from every other type's pull:
+ *
+ *   1. **A function is more than its file.** The active config VERSION holds an
+ *      envelope with the authored TOML bytes and every source file, so the pull
+ *      writes `functions/<key>.toml` plus the TypeScript beside it, and records
+ *      the source paths so prune can remove the code with the function.
+ *   2. **Bytes, not a re-serialization.** The stored TOML is written verbatim,
+ *      so comments, key order and line endings survive the round trip (F-009).
+ *      A function that has never had code pushed has no stored bytes; that one
+ *      gets a canonical serialization of its header, which is still a pushable
+ *      file.
+ *
+ * A stored source path is never trusted: `planFunctionPull` refuses one that
+ * normalizes outside the tree, and the refusals are reported rather than
+ * swallowed.
+ */
+export declare function pullFunctions(client: ApiClient, appId: string, configDir: string, logger?: (msg: string) => void, selects?: (key: string) => boolean): Promise<{
+    functionEntities: Record<string, {
+        id: string;
+        modifiedAt: string;
+        contentHash?: string;
+        semanticHash?: string;
+        envelopeHash?: string;
+        activeConfigId?: string;
+        sources?: string[];
+    }>;
+    count: number;
+    presence: PresenceOutcome;
+    listOk: boolean;
+    serverKeys: string[];
+    /**
+     * Everything the server listed, archived rows included. Pull exports no file
+     * for a tombstone, so without the row here the archived function would be
+     * stranded: no file to delete and no managed key to prune, and its key would
+     * go on blocking the app's whole namespace with nothing able to reclaim it.
+     * The caller folds these into the state through `archivedTombstoneEntries`.
+     */
+    items: any[];
+}>;
 /** The outcome of one block's test-case pull (#2769). */
 export type TestCasePullOutcome = 
 /** The listing succeeded; `count` cases were written and stale files removed. */
@@ -2091,25 +2458,6 @@ export declare function pushTestCasesForBlock(params: {
 }): Promise<{
     skipped: number;
 }>;
-/**
- * The file name each live test case belongs in (#2896).
- *
- * A KEYED case is named by its key: that is what the key is — the basename the
- * committed tree carries. An unkeyed one (created by web-admin, an older CLI or
- * the raw API) keeps the slug-of-name naming, with the collision suffixes
- * resolved only AFTER the keys have claimed theirs, so a slug can never take a
- * name a key owns.
- *
- * One function for pull, for pairing's adoption pass and for the diff's
- * remote-only rows, because three commands that name a case's file differently
- * is the disagreement this issue reports.
- *
- * Two names that differ only by CASE are one file on a case-insensitive
- * filesystem, so occupancy is tracked the way the server's key constraint
- * normalizes: a keyed `Foo` and an unkeyed case named "foo" get `Foo.toml` and
- * `foo-2.toml`, rather than one pull silently overwriting the other's sidecar.
- */
-export declare function testCaseFileBasenames(liveCases: any[], onUnusableKey?: (live: any, reason: string) => void, isSafeName?: (name: string) => boolean): Map<any, string>;
 /**
  * Whether a sidecar and a live case say the same thing (#2896).
  *
@@ -2316,8 +2664,7 @@ export declare function applyTestCasePrune(params: {
  * `registerConfigCommands` created rather than making one of its own.
  *
  * The module keeps its name and its ~50 exported helpers: `sync.ts`,
- * `resolveSyncDir`, `.primitive-sync.json` and `.primitive/sync/<env>/<appId>/`
+ * `resolveSyncDir`, the sync-state baseline and `primitive/<env>/`
  * are internal identifiers, deliberately left alone (#2759 scope).
  */
 export declare function registerConfigSyncCommands(sync: Command): void;
-export {};