@nyte-ai/plugin 0.0.0-stage → 0.0.19

package/dist/src/approvals/schema.js

@@ -0,0 +1,18 @@
+import {
+  PERMISSIONS2,
+  approvalPolicy2,
+  APPROVAL_POLICIES2,
+  APPROVAL_ACTIONS2,
+  approvalPrompt2,
+  approval2,
+  openApprovals2
+} from "../../chunks/billing-h13r0byk.js";
+export {
+  APPROVAL_ACTIONS2 as APPROVAL_ACTIONS,
+  APPROVAL_POLICIES2 as APPROVAL_POLICIES,
+  PERMISSIONS2 as PERMISSIONS,
+  approval2 as approval,
+  approvalPolicy2 as approvalPolicy,
+  approvalPrompt2 as approvalPrompt,
+  openApprovals2 as openApprovals
+};

package/dist/src/bash-description.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Makes the model say what each `bash` call does. A derive wraps the
+ * environment's `bash` tool, keeping its identity, execute and class, and
+ * requires `description` in its parameters; the tool's class already carries
+ * it as `ToolClass.shell.description`, so a client heads the call with it.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    activate(api: {
+        readonly side: "core";
+        readonly sdk: import("@nyte-ai/core").Connection;
+        readonly contribute: import("@nyte-ai/core").Registries<"core">;
+        readonly storage: import("@nyte-ai/core").PluginStorage;
+        readonly signal: AbortSignal;
+        hook<N extends "session_activated" | "before_send" | "run_started" | "transform_transcript" | "before_compaction" | "before_request" | "before_tool" | "after_tool" | "after_request" | "run_ended">(name: N, entry: import("@nyte-ai/core").HookEntry<"core", N>): import("@nyte-ai/schema").Disposer;
+        report(issue: import("@nyte-ai/schema").ValidationIssue): void;
+        reload(): void;
+    } & {
+        readonly session: import("@nyte-ai/core").Session;
+        readonly env: import("@nyte-ai/core").ExecutionEnv;
+        wrapEnv(wrap: import("@nyte-ai/core").EnvironmentWrap): import("@nyte-ai/schema").Disposer;
+        readonly inputs: import("@nyte-ai/core").Resources;
+        request<T = string>(input: import("@nyte-ai/schema").ModelRequestInput<T>): Promise<import("@nyte-ai/schema").ModelRequestOutcome<T>>;
+        approve(call: import("@nyte-ai/core").RuntimeCall, signal: AbortSignal): Promise<import("@nyte-ai/core").RuntimeVerdict>;
+    }): void;
+};
+export default _default;

package/dist/src/bash-description.js

@@ -0,0 +1,18 @@
+// src/bash-description.ts
+import { standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var parameters = standard(Type.Object({
+  command: Type.String({ description: "The shell command to run." }),
+  description: Type.String({
+    description: "Clear, concise description of what this command does in 5-10 words, in active voice."
+  })
+}));
+var bash_description_default = {
+  id: "bash-description",
+  activate(api) {
+    api.contribute.tools.add((draft) => draft.wrap("bash", (bash) => ({ ...bash, parameters })));
+  }
+};
+export {
+  bash_description_default as default
+};

package/dist/src/browser-tools.d.ts

@@ -0,0 +1,25 @@
+import type { ToolDefinition } from "@nyte-ai/core";
+/**
+ * The browser tools: open, snapshot, click, type, press, scroll, wait,
+ * console, capture and evaluate, over the workspace's browser capability
+ * (`workspace.browser()`, which a desktop adds through `wrapEnv`). Actions
+ * address nodes by the refs of the latest snapshot.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const browserTools: readonly ToolDefinition[];
+/**
+ * Adds the browser tools to every session; a session whose workspace has no
+ * browser answers each call with why.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        tools: readonly ToolDefinition<unknown, unknown>[];
+    };
+};
+export default _default;

package/dist/src/browser-tools.js

@@ -0,0 +1,246 @@
+var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
+var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    var dispose;
+    if (async)
+      dispose = value[__asyncDispose];
+    if (dispose === undefined)
+      dispose = value[__dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
+
+// src/browser-tools.ts
+import { asId, standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var page = Type.Optional(Type.String({ description: "The page id; omit for the page opened last." }));
+var ref = Type.String({ description: "A node's ref from the latest snapshot." });
+function on(properties) {
+  return standard(Type.Object({ page, ...properties }));
+}
+async function requireBrowser(invocation) {
+  const capability = await invocation.workspace.browser();
+  if (capability.kind !== "available")
+    throw new Error(`No browser is available here: ${capability.reason}`);
+  return capability.api;
+}
+async function withPage(invocation, id, operate) {
+  let __stack = [];
+  try {
+    const browser = await requireBrowser(invocation);
+    const target = id ?? (await browser.list()).at(-1)?.id;
+    if (target === undefined)
+      throw new Error("No page is open. Call browser_open first.");
+    const held = __using(__stack, await browser.adopt(asId(target)), 1);
+    return operate(held);
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    var _promise = __callDispose(__stack, _err, _hasErr);
+    _promise && await _promise;
+  }
+}
+function render(snapshot) {
+  return [
+    `Revision ${snapshot.revision}`,
+    ...snapshot.nodes.map((node) => `${"  ".repeat(node.depth)}[${node.ref}] ${node.role} "${node.name}"${node.editable ? " (editable)" : ""}`)
+  ].join(`
+`);
+}
+function outcomeText(outcome) {
+  if (outcome.kind === "applied")
+    return render(outcome.snapshot);
+  if (outcome.kind === "stale")
+    return `The page changed (now revision ${outcome.revision}). Take a snapshot and try again.`;
+  return outcome.kind === "refused" ? `Refused: ${outcome.reason}.` : `The page is closed: ${outcome.reason}.`;
+}
+function browserTool(input) {
+  return {
+    name: input.name,
+    description: input.description,
+    parameters: input.parameters,
+    class: () => ({ kind: "custom", label: input.name.replace("browser_", "Browser: ") }),
+    effects: "none",
+    approval: input.approval,
+    replay: input.replay,
+    execute: async (args, invocation) => ({
+      content: [{ kind: "text", text: await input.run(args, invocation) }]
+    })
+  };
+}
+var open = {
+  name: "browser_open",
+  description: "Open a URL in a new browser page and return the page id and its snapshot.",
+  parameters: standard(Type.Object({ url: Type.String({ minLength: 1, description: "The URL to open." }) })),
+  class: (args) => ({ kind: "custom", label: `Opening ${args.url}` }),
+  effects: "none",
+  approval: "never",
+  replay: "safe",
+  async execute(args, invocation) {
+    const opened = await (await requireBrowser(invocation)).open({ url: args.url });
+    const view = await opened.view();
+    return {
+      content: [
+        {
+          kind: "text",
+          text: `Page ${opened.id}: ${view.title} (${view.url})
+${render(await opened.snapshot())}`
+        }
+      ]
+    };
+  }
+};
+var capture = {
+  name: "browser_capture",
+  description: "Take a screenshot of the page.",
+  parameters: on({}),
+  class: () => ({ kind: "custom", label: "Browser: capture" }),
+  effects: "none",
+  approval: "never",
+  replay: "safe",
+  execute: (args, invocation) => withPage(invocation, args.page, async (held) => {
+    const image = await held.capture();
+    try {
+      const blob = await invocation.env.files.upload(image.chunks());
+      return { content: [{ kind: "file", blob, mime: image.mime ?? "image/png" }] };
+    } finally {
+      await image.close();
+    }
+  })
+};
+var browserTools = [
+  open,
+  browserTool({
+    name: "browser_snapshot",
+    description: "Read the page's accessibility tree: one line per node with its ref, role and name.",
+    parameters: on({ ref: Type.Optional(ref) }),
+    replay: "safe",
+    approval: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => render(await held.snapshot({ ref: args.ref })))
+  }),
+  browserTool({
+    name: "browser_click",
+    description: "Click a node by its ref.",
+    parameters: on({
+      ref,
+      button: Type.Optional(Type.Union([Type.Literal("left"), Type.Literal("right"), Type.Literal("middle")])),
+      double: Type.Optional(Type.Boolean())
+    }),
+    replay: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => outcomeText(await held.click({ ref: args.ref, button: args.button, double: args.double })))
+  }),
+  browserTool({
+    name: "browser_type",
+    description: "Type text into a node by its ref.",
+    parameters: on({
+      ref,
+      text: Type.String(),
+      clear: Type.Optional(Type.Boolean()),
+      submit: Type.Optional(Type.Boolean())
+    }),
+    replay: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => outcomeText(await held.type({
+      ref: args.ref,
+      text: args.text,
+      clear: args.clear,
+      submit: args.submit
+    })))
+  }),
+  browserTool({
+    name: "browser_press",
+    description: "Press a key or chord, such as Enter or Control+a, on a node or the page.",
+    parameters: on({ key: Type.String(), ref: Type.Optional(ref) }),
+    replay: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => outcomeText(await held.press({ key: args.key, ref: args.ref })))
+  }),
+  browserTool({
+    name: "browser_scroll",
+    description: "Scroll the page or a node.",
+    parameters: on({
+      direction: Type.Union([
+        Type.Literal("up"),
+        Type.Literal("down"),
+        Type.Literal("top"),
+        Type.Literal("bottom")
+      ]),
+      ref: Type.Optional(ref),
+      pages: Type.Optional(Type.Number({ minimum: 0.1 }))
+    }),
+    replay: "never",
+    approval: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => outcomeText(await held.scroll({ direction: args.direction, ref: args.ref, pages: args.pages })))
+  }),
+  browserTool({
+    name: "browser_wait",
+    description: "Wait for the page to load, for text to appear or disappear, or for a delay in milliseconds.",
+    parameters: on({
+      for: Type.Union([Type.Literal("loaded"), Type.Literal("text"), Type.Literal("delay")]),
+      text: Type.Optional(Type.String()),
+      gone: Type.Optional(Type.Boolean({ description: "With text: wait for it to disappear." })),
+      ms: Type.Optional(Type.Number({ minimum: 0 }))
+    }),
+    replay: "never",
+    approval: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => outcomeText(await held.wait(args.for === "text" ? { kind: "text", text: args.text ?? "", present: args.gone !== true } : args.for === "delay" ? { kind: "delay", ms: args.ms ?? 1000 } : { kind: "loaded" })))
+  }),
+  browserTool({
+    name: "browser_console",
+    description: "Read the page's console, newest first.",
+    parameters: on({
+      limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200 })),
+      clear: Type.Optional(Type.Boolean())
+    }),
+    replay: "never",
+    approval: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => {
+      const entries = await held.console({ limit: args.limit, clear: args.clear });
+      return entries.length === 0 ? "The console is empty." : entries.map((entry) => `[${entry.level}] ${entry.text}`).join(`
+`);
+    })
+  }),
+  capture,
+  browserTool({
+    name: "browser_evaluate",
+    description: "Evaluate a JavaScript expression in the page; with a ref, the node is `this`.",
+    parameters: on({ expression: Type.String(), ref: Type.Optional(ref) }),
+    replay: "never",
+    run: (args, invocation) => withPage(invocation, args.page, async (held) => {
+      const result = await held.evaluate(args.expression, { ref: args.ref });
+      return result.kind === "value" ? JSON.stringify(result.value) : `Threw: ${result.message}`;
+    })
+  })
+];
+var browser_tools_default = {
+  id: "browser-tools",
+  contribute: { tools: browserTools }
+};
+export {
+  browserTools,
+  browser_tools_default as default
+};

package/dist/src/canvas/canvas-compile.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Returns what the compiler answers for one canvas: the ESM module to ship,
+ * with the runtime it targets, or the diagnostics the model fixes.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CompileOutcome = {
+    readonly kind: "compiled";
+    readonly code: string;
+    readonly runtime: number;
+} | {
+    readonly kind: "failed";
+    readonly errors: readonly CompileError[];
+};
+/**
+ * Returns one diagnostic, positioned in a source file when the compiler
+ * knows where; `file` is null for one about the canvas as a whole.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CompileError = {
+    readonly file: string | null;
+    readonly line: number | null;
+    readonly column: number | null;
+    readonly text: string;
+};
+/**
+ * Returns a canvas's other files, keyed by their path from `main.tsx`'s
+ * folder, such as `chart.tsx` or `lib/scale.ts`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasFiles = Readonly<Record<string, string>>;
+/**
+ * Compiles a canvas, `source` as `main.tsx` plus the `files` it imports,
+ * to the one module the shell imports. The caps default to the contract's;
+ * a test narrows them.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function compileCanvas(source: string, files?: CanvasFiles, limits?: {
+    readonly source?: number;
+    readonly code?: number;
+}): Promise<CompileOutcome>;

package/dist/src/canvas/canvas-compile.js

@@ -0,0 +1,8 @@
+import {
+  compileCanvas2
+} from "../../chunks/billing-kn3d30b4.js";
+import"../../chunks/billing-bv5zr32b.js";
+import"../../chunks/billing-zfpm2rt0.js";
+export {
+  compileCanvas2 as compileCanvas
+};

package/dist/src/canvas/canvas-libraries.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The libraries a canvas may import, each pinned in packages/canvas and
+ * served by the shell as its own chunk, with every name its module exports.
+ * Written by `packages/canvas/scripts/library-exports.mjs`; a canvas test
+ * checks it against the installed packages.
+ */
+export declare const CANVAS_LIBRARIES: {
+    readonly three: {
+        readonly version: "0.186.1";
+        readonly exports: "ACESFilmicToneMapping AddEquation AddOperation AdditiveAnimationBlendMode AdditiveBlending AgXToneMapping AlphaFormat AlwaysCompare AlwaysDepth AlwaysStencilFunc AmbientLight AnimationAction AnimationClip AnimationLoader AnimationMixer AnimationObjectGroup AnimationUtils ArcCurve ArrayCamera ArrowHelper AttachedBindMode Audio AudioAnalyser AudioContext AudioListener AudioLoader AxesHelper BackSide BasicDepthPacking BasicShadowMap BatchedMesh BezierInterpolant Bone BooleanKeyframeTrack Box2 Box3 Box3Helper BoxGeometry BoxHelper BufferAttribute BufferGeometry BufferGeometryLoader ByteType Cache Camera CameraHelper CanvasTexture CapsuleGeometry CatmullRomCurve3 CineonToneMapping CircleGeometry ClampToEdgeWrapping Clock Color ColorKeyframeTrack ColorManagement Compatibility CompressedArrayTexture CompressedCubeTexture CompressedTexture CompressedTextureLoader ConeGeometry ConstantAlphaFactor ConstantColorFactor Controls CubeCamera CubeDepthTexture CubeReflectionMapping CubeRefractionMapping CubeTexture CubeTextureLoader CubeUVReflectionMapping CubicBezierCurve CubicBezierCurve3 CubicInterpolant CullFaceBack CullFaceFront CullFaceFrontBack CullFaceNone Curve CurvePath CustomBlending CustomToneMapping CylinderGeometry Cylindrical Data3DTexture DataArrayTexture DataTexture DataTextureLoader DataUtils DecrementStencilOp DecrementWrapStencilOp DefaultLoadingManager DepthFormat DepthStencilFormat DepthTexture DetachedBindMode DirectionalLight DirectionalLightHelper DiscreteInterpolant DodecahedronGeometry DoubleSide DstAlphaFactor DstColorFactor DynamicCopyUsage DynamicDrawUsage DynamicReadUsage EdgesGeometry EllipseCurve EqualCompare EqualDepth EqualStencilFunc EquirectangularReflectionMapping EquirectangularRefractionMapping Euler EventDispatcher ExternalTexture ExtrudeGeometry FileLoader Float16BufferAttribute Float32BufferAttribute FloatType Fog FogExp2 FramebufferTexture FrontSide Frustum FrustumArray GLBufferAttribute GLSL1 GLSL3 GreaterCompare GreaterDepth GreaterEqualCompare GreaterEqualDepth GreaterEqualStencilFunc GreaterStencilFunc GridHelper Group HTMLTexture HalfFloatType HemisphereLight HemisphereLightHelper IcosahedronGeometry ImageBitmapLoader ImageLoader ImageUtils IncrementStencilOp IncrementWrapStencilOp InstancedBufferAttribute InstancedBufferGeometry InstancedInterleavedBuffer InstancedMesh Int16BufferAttribute Int32BufferAttribute Int8BufferAttribute IntType InterleavedBuffer InterleavedBufferAttribute Interpolant InterpolateBezier InterpolateDiscrete InterpolateLinear InterpolateSmooth InterpolationSamplingMode InterpolationSamplingType InvertStencilOp KeepStencilOp KeyframeTrack LOD LatheGeometry Layers LessCompare LessDepth LessEqualCompare LessEqualDepth LessEqualStencilFunc LessStencilFunc Light LightProbe LightShadow Line Line3 LineBasicMaterial LineCurve LineCurve3 LineDashedMaterial LineLoop LineSegments LinearFilter LinearInterpolant LinearMipMapLinearFilter LinearMipMapNearestFilter LinearMipmapLinearFilter LinearMipmapNearestFilter LinearSRGBColorSpace LinearToneMapping LinearTransfer Loader LoaderUtils LoadingManager LoopOnce LoopPingPong LoopRepeat MOUSE Material MaterialBlending MaterialLoader MathUtils Matrix2 Matrix3 Matrix4 MaxEquation Mesh MeshBasicMaterial MeshDepthMaterial MeshDistanceMaterial MeshLambertMaterial MeshMatcapMaterial MeshNormalMaterial MeshPhongMaterial MeshPhysicalMaterial MeshStandardMaterial MeshToonMaterial MinEquation MirroredRepeatWrapping MixOperation MultiplyBlending MultiplyOperation NearestFilter NearestMipMapLinearFilter NearestMipMapNearestFilter NearestMipmapLinearFilter NearestMipmapNearestFilter NeutralToneMapping NeverCompare NeverDepth NeverStencilFunc NoBlending NoColorSpace NoNormalPacking NoToneMapping NormalAnimationBlendMode NormalBlending NormalGAPacking NormalRGPacking NotEqualCompare NotEqualDepth NotEqualStencilFunc NumberKeyframeTrack Object3D ObjectLoader ObjectSpaceNormalMap OctahedronGeometry OneFactor OneMinusConstantAlphaFactor OneMinusConstantColorFactor OneMinusDstAlphaFactor OneMinusDstColorFactor OneMinusSrcAlphaFactor OneMinusSrcColorFactor OrthographicCamera PCFShadowMap PCFSoftShadowMap PMREMGenerator Path PerspectiveCamera Plane PlaneGeometry PlaneHelper PointLight PointLightHelper Points PointsMaterial PolarGridHelper PolyhedronGeometry PositionalAudio PropertyBinding PropertyMixer QuadraticBezierCurve QuadraticBezierCurve3 Quaternion QuaternionKeyframeTrack QuaternionLinearInterpolant R11_EAC_Format RED_GREEN_RGTC2_Format RED_RGTC1_Format REVISION RG11_EAC_Format RGBADepthPacking RGBAFormat RGBAIntegerFormat RGBA_ASTC_10x10_Format RGBA_ASTC_10x5_Format RGBA_ASTC_10x6_Format RGBA_ASTC_10x8_Format RGBA_ASTC_12x10_Format RGBA_ASTC_12x12_Format RGBA_ASTC_4x4_Format RGBA_ASTC_5x4_Format RGBA_ASTC_5x5_Format RGBA_ASTC_6x5_Format RGBA_ASTC_6x6_Format RGBA_ASTC_8x5_Format RGBA_ASTC_8x6_Format RGBA_ASTC_8x8_Format RGBA_BPTC_Format RGBA_ETC2_EAC_Format RGBA_PVRTC_2BPPV1_Format RGBA_PVRTC_4BPPV1_Format RGBA_S3TC_DXT1_Format RGBA_S3TC_DXT3_Format RGBA_S3TC_DXT5_Format RGBDepthPacking RGBFormat RGBIntegerFormat RGB_BPTC_SIGNED_Format RGB_BPTC_UNSIGNED_Format RGB_ETC1_Format RGB_ETC2_Format RGB_PVRTC_2BPPV1_Format RGB_PVRTC_4BPPV1_Format RGB_S3TC_DXT1_Format RGDepthPacking RGFormat RGIntegerFormat RawShaderMaterial Ray Raycaster RectAreaLight RedFormat RedIntegerFormat ReinhardToneMapping RenderObjectRefreshType RenderTarget RenderTarget3D RepeatWrapping ReplaceStencilOp ReverseSubtractEquation RingGeometry SIGNED_R11_EAC_Format SIGNED_RED_GREEN_RGTC2_Format SIGNED_RED_RGTC1_Format SIGNED_RG11_EAC_Format SRGBColorSpace SRGBTransfer Scene ShaderChunk ShaderLib ShaderMaterial ShadowMaterial Shape ShapeGeometry ShapePath ShapeUtils ShortType Skeleton SkeletonHelper SkinnedMesh Source Sphere SphereGeometry Spherical SphericalHarmonics3 SplineCurve SpotLight SpotLightHelper Sprite SpriteMaterial SrcAlphaFactor SrcAlphaSaturateFactor SrcColorFactor StaticCopyUsage StaticDrawUsage StaticReadUsage StereoCamera StreamCopyUsage StreamDrawUsage StreamReadUsage StringKeyframeTrack SubtractEquation SubtractiveBlending TOUCH TangentSpaceNormalMap TetrahedronGeometry Texture TextureLoader TextureSource TextureUtils Timer TimestampQuery TorusGeometry TorusKnotGeometry Triangle TriangleFanDrawMode TriangleStripDrawMode TrianglesDrawMode TubeGeometry UVMapping Uint16BufferAttribute Uint32BufferAttribute Uint8BufferAttribute Uint8ClampedBufferAttribute Uniform UniformsGroup UniformsLib UniformsUtils UnsignedByteType UnsignedInt101111Type UnsignedInt248Type UnsignedInt5999Type UnsignedIntType UnsignedShort4444Type UnsignedShort5551Type UnsignedShortType VSMShadowMap Vector2 Vector3 Vector4 VectorKeyframeTrack VideoFrameTexture VideoTexture WebGL3DRenderTarget WebGLArrayRenderTarget WebGLCoordinateSystem WebGLCubeRenderTarget WebGLRenderTarget WebGLRenderer WebGLUtils WebGPUCoordinateSystem WebXRController WireframeGeometry WrapAroundEnding ZeroCurvatureEnding ZeroFactor ZeroSlopeEnding ZeroStencilOp createCanvasElement error getConsoleFunction log setConsoleFunction warn warnOnce";
+    };
+    readonly "d3-array": {
+        readonly version: "3.2.4";
+        readonly exports: "Adder InternMap InternSet ascending bin bisect bisectCenter bisectLeft bisectRight bisector blur blur2 blurImage count cross cumsum descending deviation difference disjoint every extent fcumsum filter flatGroup flatRollup fsum greatest greatestIndex group groupSort groups histogram index indexes intersection least leastIndex map max maxIndex mean median medianIndex merge min minIndex mode nice pairs permute quantile quantileIndex quantileSorted quickselect range rank reduce reverse rollup rollups scan shuffle shuffler some sort subset sum superset thresholdFreedmanDiaconis thresholdScott thresholdSturges tickIncrement tickStep ticks transpose union variance zip";
+    };
+    readonly "d3-scale": {
+        readonly version: "4.0.2";
+        readonly exports: "scaleBand scaleDiverging scaleDivergingLog scaleDivergingPow scaleDivergingSqrt scaleDivergingSymlog scaleIdentity scaleImplicit scaleLinear scaleLog scaleOrdinal scalePoint scalePow scaleQuantile scaleQuantize scaleRadial scaleSequential scaleSequentialLog scaleSequentialPow scaleSequentialQuantile scaleSequentialSqrt scaleSequentialSymlog scaleSqrt scaleSymlog scaleThreshold scaleTime scaleUtc tickFormat";
+    };
+    readonly "d3-shape": {
+        readonly version: "3.2.0";
+        readonly exports: "arc area areaRadial curveBasis curveBasisClosed curveBasisOpen curveBumpX curveBumpY curveBundle curveCardinal curveCardinalClosed curveCardinalOpen curveCatmullRom curveCatmullRomClosed curveCatmullRomOpen curveLinear curveLinearClosed curveMonotoneX curveMonotoneY curveNatural curveStep curveStepAfter curveStepBefore line lineRadial link linkHorizontal linkRadial linkVertical pie pointRadial radialArea radialLine stack stackOffsetDiverging stackOffsetExpand stackOffsetNone stackOffsetSilhouette stackOffsetWiggle stackOrderAppearance stackOrderAscending stackOrderDescending stackOrderInsideOut stackOrderNone stackOrderReverse symbol symbolAsterisk symbolCircle symbolCross symbolDiamond symbolDiamond2 symbolPlus symbolSquare symbolSquare2 symbolStar symbolTimes symbolTriangle symbolTriangle2 symbolWye symbolX symbols symbolsFill symbolsStroke";
+    };
+    readonly "d3-hierarchy": {
+        readonly version: "3.1.2";
+        readonly exports: "Node cluster hierarchy pack packEnclose packSiblings partition stratify tree treemap treemapBinary treemapDice treemapResquarify treemapSlice treemapSliceDice treemapSquarify";
+    };
+    readonly "d3-force": {
+        readonly version: "3.0.0";
+        readonly exports: "forceCenter forceCollide forceLink forceManyBody forceRadial forceSimulation forceX forceY";
+    };
+};

package/dist/src/canvas/canvas-libraries.js

@@ -0,0 +1,6 @@
+import {
+  CANVAS_LIBRARIES2
+} from "../../chunks/billing-zfpm2rt0.js";
+export {
+  CANVAS_LIBRARIES2 as CANVAS_LIBRARIES
+};

package/dist/src/canvas/canvas-preview.d.ts

@@ -0,0 +1,107 @@
+import type { CanvasModule } from "./canvas-protocol.ts";
+/** The widths a preview measures at, in CSS pixels: the desktop chat column (its 840 px measure less the gutters) and a phone's. */
+export declare const CANVAS_PREVIEW_WIDTHS: {
+    readonly chat: 808;
+    readonly phone: 358;
+};
+/**
+ * Returns what a previewer renders: the compiled module and the theme to
+ * show it in.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasPreviewRequest = {
+    readonly module: CanvasModule;
+    readonly theme: "light" | "dark";
+};
+/**
+ * Returns one error the shell reported while the preview ran, its message
+ * ending in the canvas file and line when the stack named one.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasPreviewError = {
+    readonly phase: "load" | "render";
+    readonly message: string;
+    readonly stack: string | null;
+};
+/**
+ * Returns one console call the canvas made while the preview ran.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasPreviewLog = {
+    readonly level: string;
+    readonly text: string;
+};
+/**
+ * Returns what a preview saw: a PNG of the canvas at the chat column's
+ * width, its height there and at a phone's (`CANVAS_PREVIEW_WIDTHS`), its
+ * errors and its console.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasPreviewReport = {
+    readonly png: Uint8Array;
+    readonly heights: {
+        readonly chat: number;
+        readonly phone: number;
+    };
+    readonly errors: readonly CanvasPreviewError[];
+    readonly console: readonly CanvasPreviewLog[];
+};
+/**
+ * Returns a previewer's answer: the report, or why this host cannot render
+ * a preview (no renderer installed, the renderer failed to start).
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasPreviewOutcome = {
+    readonly kind: "rendered";
+    readonly report: CanvasPreviewReport;
+} | {
+    readonly kind: "unavailable";
+    readonly reason: string;
+};
+/**
+ * Renders a compiled canvas off-screen in the real shell. A host passes one
+ * to `canvasPlugin` to give the model `canvas_preview`, which gives each
+ * preview 45 seconds. When `signal` aborts (past that, or the turn
+ * stopped), the previewer tears its renderer down, so a canvas that hangs
+ * its page holds up no later preview.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasPreviewer = (request: CanvasPreviewRequest, signal: AbortSignal) => Promise<CanvasPreviewOutcome>;
+/**
+ * Returns the page a previewer loaded the shell in, top-level, for
+ * `runCanvasPreview` to drive: `evaluate` runs an expression in the page
+ * and resolves with its JSON-safe value (awaiting a promise), `resize` sets
+ * the viewport in CSS pixels, `capture` takes a PNG of the viewport.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type CanvasPreviewPage = {
+    evaluate(expression: string): Promise<unknown>;
+    resize(width: number, height: number): Promise<void>;
+    capture(): Promise<Uint8Array>;
+};
+/**
+ * Runs a preview on a page that has loaded the shell: installs the harness
+ * (retrying while the shell's script has not run yet), settles at the chat
+ * column's width and captures it there, then settles again at a phone's
+ * width for its height.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function runCanvasPreview(page: CanvasPreviewPage, request: CanvasPreviewRequest): Promise<CanvasPreviewReport>;
+/** Returns the preview as the model reads it beside the screenshot: heights, errors, console. */
+export declare function describeCanvasPreview(report: CanvasPreviewReport): string;

package/dist/src/canvas/canvas-preview.js

@@ -0,0 +1,12 @@
+import {
+  CANVAS_PREVIEW_WIDTHS2,
+  runCanvasPreview2,
+  describeCanvasPreview2
+} from "../../chunks/billing-sxc70w72.js";
+import"../../chunks/billing-bv5zr32b.js";
+import"../../chunks/billing-zfpm2rt0.js";
+export {
+  CANVAS_PREVIEW_WIDTHS2 as CANVAS_PREVIEW_WIDTHS,
+  describeCanvasPreview2 as describeCanvasPreview,
+  runCanvasPreview2 as runCanvasPreview
+};