primitive-admin 1.2.0-alpha.4 → 1.2.0-alpha.5

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

@@ -1,7 +1,5 @@
 import { Command } from "commander";
 import { ApiClient } from "../lib/api-client.js";
-import { type OperationFormHints } from "../lib/toml-database-config.js";
-import { type FieldForm } from "../lib/toml-native-form.js";
 import { type PullWriteTally } from "../lib/pull-write.js";
 import { type PushMode } from "../lib/config-payload.js";
 import { type ConfigObjectSurface, type ConfigTable } from "../lib/generated-config-surfaces.js";
@@ -760,23 +758,26 @@ export declare function promptConfigPayload(tomlConfig: any, options?: {
 export declare function buildBlobBucketCreatePayload(key: string, bucket: any): Record<string, any>;
 export declare function serializePrompt(prompt: any, logger?: (message: string) => void): string;
 /**
- * The `config push` warning for a resource pushed with no `accessRule` (#2652).
+ * The `config push` warning for a caller workflow pushed with no `accessRule`
+ * (#2652).
  *
  * Returns `null` when a rule is declared — and for a `runAs = "system"`
  * workflow, which rejects any rule and cannot be started by a member at all.
- * Otherwise it names the resource, the consequence, and the one-line restore,
- * because after the #2652 flip a ruleless prompt or caller workflow denies
- * every non-admin caller from the deploy onward.
+ * Otherwise it names the workflow, the consequence, and the one-line restore,
+ * because after the #2652 flip a ruleless caller workflow denies every
+ * non-admin caller from the deploy onward.
  *
- * Both kinds now push `accessRule` as value-or-`null` — the prompt since #1567,
- * the workflow since #2743's always-send conversion — so for either one an
- * omitted key really does leave the resource ruleless on the server. The
- * workflow wording says so explicitly, because it used to say the opposite
- * (the update path preserved a stored rule) and an operator who learned that
- * caveat needs to see it retracted.
+ * A prompt gets no warning (#4368): a server function runs it on its
+ * `prompt:<key>` grant, which never consults the rule, so a ruleless prompt is
+ * the ordinary case, not a lockout.
+ *
+ * The workflow pushes `accessRule` as value-or-`null` since #2743's
+ * always-send conversion, so an omitted key really does leave it ruleless on
+ * the server. The wording says so explicitly, because it used to say the
+ * opposite (the update path preserved a stored rule) and an operator who
+ * learned that caveat needs to see it retracted.
  */
 export declare function missingAccessRuleWarning(opts: {
-    kind: "prompt" | "workflow";
     key: string;
     accessRule: unknown;
     runAs?: unknown;
@@ -1012,6 +1013,21 @@ export declare function partitionPromptFilesForPush(promptsDir: string, files: r
     beforeFunctions: string[];
     afterFunctions: string[];
 };
+/**
+ * The deferred agent files `config push` can still apply — #4437. An agent
+ * that names a function this push failed to apply, and that the server does
+ * not already hold, would only be refused as naming a function the app does
+ * not have. It is held back instead, with a failure that names the function as
+ * the cause; the function's own failure row says why. A file that does not
+ * parse is left for the prompt leg to report.
+ */
+export declare function holdAgentPromptFilesForUnappliedFunctions(promptsDir: string, files: readonly string[], unappliedFunctionKeys: ReadonlySet<string>): {
+    apply: string[];
+    held: Array<{
+        key: string;
+        message: string;
+    }>;
+};
 /**
  * Every `prompts/<key>.tests/*.toml` sidecar the agent test case's rule
  * refuses — #4262 (#3798 refused every sidecar on an agent). An agent's case
@@ -1176,15 +1192,9 @@ export declare function workflowPushSendsUpdate(configDir: string, key: string,
 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?: {
-    /** Per-op form hints derived from the existing file. */
-    hints?: OperationFormHints;
-    /** Default form for ops with no hint. New files → "native". */
-    defaultForm?: FieldForm;
-    /** Sink for human-readable fallback messages (logged via `info`). */
+export declare function serializeDatabaseType(typeConfig: any, ruleSetIdToName: Map<string, string>, options?: {
+    /** Sink for human-readable messages (logged via `info`). */
     logger?: (message: string) => void;
-    /** Server subscription rows to emit as `[[subscriptions]]` (issue #803). */
-    subscriptions?: any[];
 }): string;
 /**
  * Flatten an email-template detail response onto its field surface.
@@ -1291,46 +1301,8 @@ export declare function buildOwnedScalarUpdate(typeConfig: any): Record<string,
  * GET; without it (fresh type or a failed fetch) nothing is reported cleared.
  */
 export declare function ownedScalarsBeingCleared(updateData: Record<string, any>, serverConfig: any): string[];
-/** The look-ahead a type-config PATCH carries about this push's operations. */
-export interface PendingOpClaims {
-    pendingOpDeletes: string[];
-    finalOpNames: string[];
-    pendingOpUpdates: Array<{
-        name: string;
-        access: string | null;
-        params: any;
-    }>;
-    pendingOpUpserts: Array<Record<string, any>>;
-}
-/**
- * What this push's operation set will BE, stated to the server (issues #813,
- * #1336, #2732).
- *
- * The type-config PATCH runs its gates BEFORE the same push's operation calls,
- * so without a look-ahead every gate judges the pre-push operations: a push
- * that removes a model is blocked by the very references it is deleting. The
- * file IS the target state (config-as-code), so the claims are derived from it:
- *
- *   - `finalOpNames` — the names the type ends with. Both other claims are
- *     verified against it server-side, which is what keeps them from being a
- *     gate bypass for a direct-API caller.
- *   - `pendingOpDeletes` — its complement among the ops last sync recorded, so
- *     an op this push deletes is excluded from the schema / OPS_EXIST gates.
- *   - `pendingOpUpserts` — the post-push BODY of every declared op, so the
- *     schema-edit gate lints a rewritten op as rewritten and a model removal
- *     plus its operation rewrites lands in one push (#2732).
- *   - `pendingOpUpdates` — the rule-only form (`access`/`params`) the manifest
- *     re-lint reads (#1336).
- *
- * All four are built here and sent together, on the dry-run and on the real
- * PATCH alike. They are never conditioned on the push having a deletion: a push
- * that only REWRITES operations is exactly the case #2732 exists for.
- */
-export declare function buildPendingOpClaims(operations: any[], existingOpNames: string[]): PendingOpClaims;
 export declare function parseDatabaseTypeToml(tomlData: any): {
     typeConfig: any;
-    operations: any[];
-    subscriptions: any[];
 };
 /**
  * The parsed shape of a rule-set TOML: the definition's fields plus the
@@ -1826,28 +1798,6 @@ export declare function resolveExistingId(input: {
     liveId?: string;
     manifestId?: string;
 }): string | undefined;
-/**
- * Which CHILD rows a database type's push reconciles against (#2731 B3).
- *
- * `resolveExistingId` answers this for a whole entity; a database type's
- * operations and subscriptions are rows with the same question and the same
- * two possible answers. The manifest can name an operation the server no
- * longer has (the update PUTs a row that is gone) and be silent about one it
- * does have (the create POSTs a duplicate key) — both abort the push with a
- * server error, which is exactly the recovery `--force` is supposed to
- * perform.
- *
- * When the reconcile read the rows, they ARE the baseline: existence, the
- * timestamp each update guards with, and — as the complement of the file's own
- * list — which rows this push deletes. `undefined` means the read did not
- * happen (the degraded path, or a type live state says is absent), and the
- * manifest stays what it has always been.
- */
-export declare function liveChildBaseline(live: Map<string, any> | undefined, manifestChildren?: Record<string, {
-    modifiedAt: string;
-}>): Record<string, {
-    modifiedAt: string;
-}> | undefined;
 /**
  * The app's live rule sets, indexed the three ways push reads them (#2731 B3).
  *