@punica/editor 1.50.2 → 1.52.0

package/package.json

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

package/types/punica.module.flow.api.d.ts

@@ -109,6 +109,25 @@ declare module 'punica' {
         nodeId: CapabilityId,
         options?: { manifest?: unknown }
       ): Promise<TestReport>;
+      /**
+       * Run the tests, grade them, and keep the record beside the manifest
+       * (`<stem>.verification.json`) when every case that ran passed and at
+       * least one ran. A red run removes an earlier record of the file. The
+       * marketplace refuses a publish without this record (substrate 1.51.0).
+       */
+      verify(
+        id: CapabilityId,
+        options?: { manifest?: unknown; producedBy?: string }
+      ): Promise<{
+        color: 'green' | 'yellow' | 'red';
+        verified: boolean;
+        reason: string;
+        ran: number;
+        passed: number;
+        skipped: number;
+        record: Record<string, unknown> | null;
+        path: string | null;
+      }>;
     }
 
     export interface FlowApi {

package/types/punica.module.flow.primitives.d.ts

@@ -308,7 +308,17 @@ declare module 'punica' {
      */
     export interface ForEachPrimitiveData {
       collection: PrimitiveValueRef;
-      bodyFlowId: CapabilityId;
+      /** Decision-only body reference (no dispatch). One of this or `bodyCapabilityId`. */
+      bodyFlowId?: CapabilityId;
+      /**
+       * A capability called once per item through the gateway (substrate
+       * 1.51.0) — an IvyNode, an IvyAgent or any extension capability. Its
+       * input is `bodyInput` with the item bound at `itemBinding`; the node's
+       * output is `{ results, count, truncated }`.
+       */
+      bodyCapabilityId?: CapabilityId;
+      /** Fixed input fields for every call of `bodyCapabilityId`. */
+      bodyInput?: JSONObject;
       maxIterations: number;
       itemBinding?: string;
     }

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

@@ -251,6 +251,13 @@ declare module 'punica' {
          * and packaged builds; omitted when the host cannot resolve it.
          */
         bridgePath?: string;
+        /**
+         * The bearer token the listener requires on every JSON-RPC and SSE
+         * request (`Authorization: Bearer <token>`; the stdio bridge takes
+         * `--token`). Minted once per installation. Omitted by a host whose
+         * listener takes no token.
+         */
+        token?: string;
       }
 
       /** An inbound MCP JSON-RPC request forwarded from the transport. */

package/types/punica.module.test.d.ts

@@ -263,6 +263,13 @@ declare module 'punica' {
     sideEffects?: SideEffectCheck;
   }
 
+  /**
+   * How a test case builds one non-JSON input (see `TestCase.fixture`).
+   */
+  export interface TestFixture {
+    python: string;
+  }
+
   /**
    * Test Case
    */
@@ -279,6 +286,14 @@ declare module 'punica' {
      * Test input data
      */
     input: JSONValue | JSONObject | null;
+    /**
+     * Values the case builds in the node's own session before it runs, one
+     * per input field, for inputs that are not JSON — a client, a model, a
+     * buffer an upstream node would hand over as a handle. `python` is an
+     * expression, or a block that assigns `value`. A fixture key replaces
+     * the same key in `input`.
+     */
+    fixture?: Record<string, TestFixture>;
     /**
      * Test assertions
      */

package/types/vendor/monaco-editor.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The Monaco surface the hosts ship, for extensions that do not install it.
+ *
+ * `monaco-editor` is the product's, not an extension's: both hosts map the
+ * bare specifier to one shared `monaco-editor.bundle.js` through the renderer
+ * import map (punica-editor-browser/vendor/monaco-vendor.ts, monaco-editor
+ * ^0.53.0 in both hosts' package.json), and an extension keeps it `external`
+ * in rollup. Installing the package only for its types puts ~70 MB in every
+ * extension's node_modules and lets an extension compile against API the
+ * host's core-only bundle does not carry.
+ *
+ * **Opt in through tsconfig `paths`**, the way `punica` is mapped:
+ *
+ *   "paths": {
+ *     "punica": ["node_modules/@punica/editor/types"],
+ *     "monaco-editor": ["node_modules/@punica/editor/types/vendor/monaco-editor"]
+ *   }
+ *
+ * It is a module, not an ambient `declare module`, and it is deliberately not
+ * referenced from `types/index.d.ts`: an extension that does install the real
+ * package (extension-code-editor uses far more of it) must keep resolving to
+ * that one.
+ *
+ * Only what an extension in the fleet calls is declared. Widen it when a
+ * caller needs more — and check the member exists in the host's bundle,
+ * which is the core editor plus the python, markdown, sql, typescript and
+ * javascript tokenizers, no language services and no workers.
+ */
+
+export interface IDisposable {
+  dispose(): void;
+}
+
+export interface IPosition {
+  lineNumber: number;
+  column: number;
+}
+
+export interface IRange {
+  startLineNumber: number;
+  startColumn: number;
+  endLineNumber: number;
+  endColumn: number;
+}
+
+export enum MarkerSeverity {
+  Hint = 1,
+  Info = 2,
+  Warning = 4,
+  Error = 8,
+}
+
+export namespace editor {
+  interface IMarkerData extends IRange {
+    severity: MarkerSeverity;
+    message: string;
+  }
+
+  interface ITextModel {
+    getValue(): string;
+    getFullModelRange(): IRange;
+    getPositionAt(offset: number): IPosition;
+    getOffsetAt(position: IPosition): number;
+    pushEditOperations(
+      beforeCursorState: unknown[] | null,
+      editOperations: { range: IRange; text: string }[],
+      cursorStateComputer: () => unknown[] | null
+    ): unknown;
+    pushStackElement(): void;
+    dispose(): void;
+  }
+
+  interface IStandaloneCodeEditor {
+    getValue(): string;
+    setValue(value: string): void;
+    getModel(): ITextModel | null;
+    focus(): void;
+    dispose(): void;
+    layout(): void;
+    setSelection(range: IRange): void;
+    revealRangeInCenterIfOutsideViewport(range: IRange): void;
+    onDidChangeModelContent(listener: () => void): IDisposable;
+    updateOptions(options: Record<string, unknown>): void;
+  }
+
+  function create(
+    host: HTMLElement,
+    options: Record<string, unknown>
+  ): IStandaloneCodeEditor;
+  function setTheme(theme: string): void;
+  function setModelMarkers(
+    model: ITextModel,
+    owner: string,
+    markers: IMarkerData[]
+  ): void;
+}
+
+export namespace languages {
+  function register(language: { id: string; extensions?: string[] }): void;
+  function getLanguages(): { id: string }[];
+  function setMonarchTokensProvider(
+    languageId: string,
+    language: Record<string, unknown>
+  ): IDisposable;
+  function setLanguageConfiguration(
+    languageId: string,
+    configuration: Record<string, unknown>
+  ): IDisposable;
+}