@punica/editor 1.6.13 → 1.6.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punica/editor",
-  "version": "1.6.13",
+  "version": "1.6.15",
   "description": "Punica Editor",
   "private": false,
   "type": "module",

package/types/punica.module.kernel.events.d.ts

@@ -1,6 +1,28 @@
 declare module 'punica' {
   export namespace kernel {
-    export type KernelEventKind = 'result' | 'progress' | 'error' | 'info';
+    /**
+     * High-level kind of an event.
+     *
+     * `'audit'` is not just a label: it is the publisher's declaration that
+     * this event is a durable record, and the substrate **persists it** (see
+     * `docs/events.md` § Durability). Every other kind is persisted only if
+     * the event *name* matches one of the substrate's critical-event patterns,
+     * which is a fine default for lifecycle and failure events but cannot be
+     * relied on by a caller — an extension recording "a human promoted model
+     * version 3 to production" has no name it could choose to make that record
+     * survive a restart. Declaring `kind: 'audit'` is that mechanism.
+     *
+     * Use it for records that must outlive the session and would be a problem
+     * to lose: governed actions, approvals, promotions, irreversible writes.
+     * Do not use it for progress or telemetry — the audit ring is retained and
+     * queried, so volume there costs something real.
+     */
+    export type KernelEventKind =
+      | 'result'
+      | 'progress'
+      | 'error'
+      | 'info'
+      | 'audit';
 
     /**
      * Standard event envelope for correlation, auditing and tracing.

package/types/punica.module.runtime.fs.d.ts

@@ -192,6 +192,22 @@ declare module 'punica' {
        */
       cwd?: string;
 
+      /**
+       * Is a concrete provider installed behind this facade?
+       *
+       * **Substrate-provided — hosts must NOT implement this.** It exists only
+       * on the wrapper the substrate hands out as `punica.runtime.fs`, which is
+       * why it is optional: reading it off a raw provider object yields
+       * `undefined`, and a caller should treat that as "cannot tell, fall back".
+       *
+       * Answers without any filesystem access. Before it existed, the only way
+       * to detect a missing provider was to call a real method and match its
+       * error message — which cost a full recursive workspace walk for a
+       * boolean, and could not distinguish "no provider" from a provider that
+       * failed transiently.
+       */
+      hasProvider?(): boolean;
+
       /**
        * Returns the full file tree for the current workspace root.
        */

package/types/punica.module.runtime.search.d.ts

@@ -48,12 +48,26 @@ declare module 'punica' {
       query(options: SearchQueryOptions): Promise<SearchResponse>;
 
       /**
-       * (Optional) Trigger a full or incremental index operation.
+       * (Optional) Trigger an index operation.
        * Implementations may ignore this if indexing is managed externally.
+       *
+       * Incremental by default — a host is expected to re-read only what
+       * changed since the last pass. `rebuild` asks for a from-scratch index,
+       * which a caller should only need after changing what gets indexed.
+       *
+       * `skipped` and `rebuilt` are optional so an older host stays conformant;
+       * a host that reports them makes "the index quietly grew to a gigabyte
+       * over a virtualenv" observable instead of invisible.
        */
       startIndex?(options?: {
         verbose?: boolean;
-      }): Promise<void | { addedOrUpdated: number; removed: number }>;
+        rebuild?: boolean;
+      }): Promise<void | {
+        addedOrUpdated: number;
+        removed: number;
+        skipped?: number;
+        rebuilt?: boolean;
+      }>;
     }
   }
 }