@mininglamp-oss/octo-runtime-client 0.0.0-stage → 1.1.11

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/service-processes.js

@@ -0,0 +1,65 @@
+const record = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("INVALID_KERNEL_STATUS");
+    return value;
+};
+const positive = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+/** status 的安全进程白名单与共享 Schema 对齐，拒绝任意 argv/env 扩展字段。 */
+export function assertServiceProcessSnapshot(value) {
+    const item = record(value);
+    if (Object.keys(item).some((key) => ![
+        "scope_id",
+        "service_id",
+        "incarnation",
+        "provider",
+        "owner_pid",
+        "pid",
+        "state",
+        "observation",
+        "ownership"
+    ].includes(key)) ||
+        ["scope_id", "service_id", "provider"].some((key) => typeof item[key] !== "string" || !item[key].length) ||
+        typeof item.incarnation !== "number" ||
+        !Number.isSafeInteger(item.incarnation) ||
+        item.incarnation < 0 ||
+        !positive(item.owner_pid) ||
+        (item.pid !== undefined && !positive(item.pid)) ||
+        typeof item.state !== "string" ||
+        ![
+            "not_started",
+            "starting",
+            "ready",
+            "recovering",
+            "degraded",
+            "closing",
+            "closed",
+            "cleanup_incomplete"
+        ].includes(item.state) ||
+        typeof item.observation !== "string" ||
+        !["alive", "exited", "unknown"].includes(item.observation) ||
+        item.ownership !== "owned")
+        throw new TypeError("INVALID_KERNEL_STATUS");
+}
+/** 兼容没有服务快照的旧 status；有快照时完整校验后才能交给 doctor。 */
+export function assertKernelStatus(value) {
+    const item = record(value);
+    if (Object.keys(item).some((key) => ![
+        "ipc_version",
+        "kernel_instance_id",
+        "pid",
+        "execution_ready",
+        "service_processes"
+    ].includes(key)) ||
+        item.ipc_version !== 1 ||
+        typeof item.kernel_instance_id !== "string" ||
+        !item.kernel_instance_id ||
+        !positive(item.pid) ||
+        typeof item.execution_ready !== "boolean")
+        throw new TypeError("INVALID_KERNEL_STATUS");
+    if (item.service_processes !== undefined) {
+        if (!Array.isArray(item.service_processes) || item.service_processes.length > 256)
+            throw new TypeError("INVALID_KERNEL_STATUS");
+        for (const process of item.service_processes)
+            assertServiceProcessSnapshot(process);
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/stream-limits.d.ts

@@ -0,0 +1,27 @@
+export interface StreamLimitPolicy {
+    rawMessageMaxBytes: number;
+    adapterQueueItemMaxBytes: number;
+    adapterQueueMaxBytes: number;
+    adapterQueueMaxItems: number;
+    hostFrameMaxBytes: number;
+    rpcQueueMaxBytes: number;
+    rpcQueueMaxItems: number;
+    replayRunMaxBytes: number;
+    replayRunMaxItems: number;
+    replayGlobalMaxBytes: number;
+}
+export type StreamLimitOverrides = Partial<StreamLimitPolicy>;
+export declare const DEFAULT_STREAM_LIMIT_POLICY: Readonly<StreamLimitPolicy>;
+export declare const MAX_STREAM_LIMIT_POLICY: Readonly<StreamLimitPolicy>;
+export declare const HOST_RPC_MAX_LINE_BYTES: number;
+export declare function resolveStreamLimitPolicy(overrides: StreamLimitOverrides | undefined): Readonly<StreamLimitPolicy>;
+export declare const STREAM_CAPACITY_REASONS: readonly ["PROVIDER_MESSAGE_TOO_LARGE", "HOST_FRAME_TOO_LARGE", "STREAM_QUEUE_ITEM_TOO_LARGE", "STREAM_QUEUE_BYTES_EXCEEDED", "STREAM_QUEUE_ITEMS_EXCEEDED"];
+export type StreamCapacityReason = (typeof STREAM_CAPACITY_REASONS)[number];
+export declare function isStreamCapacityReason(value: unknown): value is StreamCapacityReason;
+export declare function streamCapacityError(code: StreamCapacityReason, detail: {
+    boundary: string;
+    measuredBytes?: number;
+    limitBytes?: number;
+    itemCount?: number;
+    limitItems?: number;
+}): Error;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/stream-limits.js

@@ -0,0 +1,56 @@
+const MIB = 1024 * 1024;
+export const DEFAULT_STREAM_LIMIT_POLICY = Object.freeze({
+    rawMessageMaxBytes: 16 * MIB,
+    adapterQueueItemMaxBytes: 20 * MIB,
+    adapterQueueMaxBytes: 32 * MIB,
+    adapterQueueMaxItems: 4096,
+    hostFrameMaxBytes: 20 * MIB,
+    rpcQueueMaxBytes: 32 * MIB,
+    rpcQueueMaxItems: 4096,
+    replayRunMaxBytes: 32 * MIB,
+    replayRunMaxItems: 4096,
+    replayGlobalMaxBytes: 128 * MIB
+});
+export const MAX_STREAM_LIMIT_POLICY = Object.freeze(Object.fromEntries(Object.entries(DEFAULT_STREAM_LIMIT_POLICY).map(([key, value]) => [key, value * 2])));
+export const HOST_RPC_MAX_LINE_BYTES = MAX_STREAM_LIMIT_POLICY.hostFrameMaxBytes + 64 * 1024;
+export function resolveStreamLimitPolicy(overrides) {
+    if (overrides !== undefined &&
+        (overrides === null || typeof overrides !== "object" || Array.isArray(overrides)))
+        throw new TypeError("stream_limits must be an object");
+    const fields = new Set(Object.keys(DEFAULT_STREAM_LIMIT_POLICY));
+    for (const key of Object.keys(overrides ?? {})) {
+        if (!fields.has(key))
+            throw new TypeError(`unknown stream_limits.${key}`);
+    }
+    const policy = { ...DEFAULT_STREAM_LIMIT_POLICY, ...(overrides ?? {}) };
+    for (const key of Object.keys(DEFAULT_STREAM_LIMIT_POLICY)) {
+        const value = policy[key];
+        if (!Number.isSafeInteger(value) || value < 1 || value > MAX_STREAM_LIMIT_POLICY[key]) {
+            throw new TypeError(`invalid stream_limits.${key}`);
+        }
+    }
+    if (policy.rawMessageMaxBytes > policy.adapterQueueItemMaxBytes)
+        throw new TypeError("stream_limits.rawMessageMaxBytes exceeds adapterQueueItemMaxBytes");
+    if (policy.adapterQueueItemMaxBytes > policy.adapterQueueMaxBytes)
+        throw new TypeError("stream_limits.adapterQueueItemMaxBytes exceeds adapterQueueMaxBytes");
+    if (policy.hostFrameMaxBytes > policy.rpcQueueMaxBytes)
+        throw new TypeError("stream_limits.hostFrameMaxBytes exceeds rpcQueueMaxBytes");
+    if (policy.hostFrameMaxBytes > policy.replayRunMaxBytes)
+        throw new TypeError("stream_limits.hostFrameMaxBytes exceeds replayRunMaxBytes");
+    if (policy.replayRunMaxBytes > policy.replayGlobalMaxBytes)
+        throw new TypeError("stream_limits.replayRunMaxBytes exceeds replayGlobalMaxBytes");
+    return Object.freeze(policy);
+}
+export const STREAM_CAPACITY_REASONS = [
+    "PROVIDER_MESSAGE_TOO_LARGE",
+    "HOST_FRAME_TOO_LARGE",
+    "STREAM_QUEUE_ITEM_TOO_LARGE",
+    "STREAM_QUEUE_BYTES_EXCEEDED",
+    "STREAM_QUEUE_ITEMS_EXCEEDED"
+];
+export function isStreamCapacityReason(value) {
+    return STREAM_CAPACITY_REASONS.includes(value);
+}
+export function streamCapacityError(code, detail) {
+    return Object.assign(new Error(code), { code, ...detail });
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-protocol",
+  "version": "1.1.11",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./browser": "./dist/browser.js",
+    "./notification": "./dist/notification.js"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ]
+}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@mininglamp-oss/octo-runtime-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.11",
+  "private": false,
+  "description": "Standalone Node.js client and shared protocol for an existing Octo Runtime Kernel",
+  "license": "Apache-2.0",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "import": "./dist/protocol.js"
+    },
+    "./protocol/browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    "./protocol/notification": {
+      "types": "./dist/notification.d.ts",
+      "import": "./dist/notification.js"
+    },
+    "./protocol/schema.json": "./schema/protocol.schema.json",
+    "./protocol/ipc-schema.json": "./schema/kernel-ipc.schema.json",
+    "./protocol/ipc-fixtures.json": "./schema/kernel-ipc-fixtures.json",
+    "./protocol/behavior.json": "./schema/kernel-client.behavior.json",
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
+    }
+  },
+  "files": [
+    "dist",
+    "schema",
+    "build-info.json"
+  ],
+  "engines": {
+    "node": "^24.0.0 || ^26.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mininglamp-OSS/octo-runtime.git",
+    "directory": "packages/octo-runtime-client"
+  },
+  "dependencies": {
+    "@mininglamp-oss/octo-runtime-protocol": "1.1.11"
+  },
+  "bundleDependencies": [
+    "@mininglamp-oss/octo-runtime-protocol"
+  ]
+}