@drawmotive/textgraph 0.2.2-alpha.2 → 0.2.2-alpha.3

package/schemas/wasm-manifest.schema.json

@@ -178,7 +178,7 @@
         "properties": {
           "capabilities": {
             "contains": {
-              "const": "textgraph-render-v1"
+              "enum": ["textgraph-render-v1", "textgraph-render-svg-v1"]
             },
             "type": "array"
           }

package/src/index.d.ts

@@ -55,6 +55,7 @@ export interface TextGraphInstance {
   renderPng(source: string, options?: TextGraphRenderPngOptions<'bytes'>): Promise<TextGraphRenderPngResult<Uint8Array>>;
   renderPng(source: string, options: TextGraphRenderPngOptions<'base64'> & { encoding: 'base64' }): Promise<TextGraphRenderPngResult<string>>;
   renderPng(source: string, options: TextGraphRenderPngOptions): Promise<TextGraphRenderPngResult<Uint8Array | string>>;
+  renderSvg(source: string, options?: TextGraphRenderSvgOptions): Promise<TextGraphRenderSvgResult>;
   readonly<T>(operation: () => T | Promise<T>): Promise<T>;
   mutate<T>(operation: () => T | Promise<T>): Promise<T>;
   dispose(): Promise<void>;
@@ -146,6 +147,20 @@ export type TextGraphRenderPngResult<Png extends Uint8Array | string = Uint8Arra
       readonly displayWidth?: number; readonly displayHeight?: number; readonly diagnostics: readonly TextGraphRenderDiagnostic[] }
   | { readonly success: false; readonly diagnostics: readonly TextGraphRenderDiagnostic[] };
 
+/** Vector export uses logical diagram units and requires textgraph-render-svg-v1. */
+export interface TextGraphRenderSvgOptions {
+  /** Optional language hint for ambiguous Han text, e.g. ja or zh-CN. */
+  language?: string;
+  /** Non-negative padding in diagram units. Defaults to 10. */
+  padding?: number;
+  /** Cancellation cannot preempt native work already running on this thread. */
+  signal?: AbortSignal;
+}
+
+export type TextGraphRenderSvgResult =
+  | { readonly success: true; readonly svg: string; readonly displayWidth: number; readonly displayHeight: number; readonly diagnostics: readonly TextGraphRenderDiagnostic[] }
+  | { readonly success: false; readonly diagnostics: readonly TextGraphRenderDiagnostic[] };
+
 export interface TextGraphRuntimeInfo extends TextGraphRuntimeManifest {
   readonly protocolVersion: 1;
   readonly capabilities: readonly string[];

package/src/index.js

@@ -3,7 +3,7 @@ import { createManagedInstance, throwIfAborted, validateAbi, waitForInitialResou
 import { decodeValidation, validateSignal } from './runtime/validation.js';
 import { DrawMotiveError } from './runtime/errors.js';
 import { normalizeFontAssets, normalizeLanguagePacks } from './runtime/language-packs.js';
-import { decodeRender, normalizeRenderOptions } from './runtime/rendering.js';
+import { decodeRender, decodeSvgRender, normalizeRenderOptions, normalizeSvgOptions } from './runtime/rendering.js';
 import manifest from '../generated/wasm-manifest.js';
 
 export { validateTextGraphAdapters } from './adapters.js';
@@ -35,25 +35,32 @@ export async function initializeTextGraph(options = {}) {
     ...(typeof runtime.execute === 'function' ? ['textgraph-render-v1'] : []),
   ];
   const info = Object.freeze({ packageName: abiManifest.packageName, packageVersion: abiManifest.packageVersion, abiVersion: runtime.abiVersion, protocolVersion: 1, capabilities: Object.freeze([...capabilities]) });
+  // Every export format uses the same operation queue and resource-preparing executor.
+  const render = async (source, callOptions, normalize, decode, capability, format) => {
+    if (instance.state !== 'ready') throw new DrawMotiveError('INSTANCE_DISPOSED', 'The runtime instance is disposing or disposed');
+    const { request, encoding, signal } = normalize(source, callOptions);
+    throwIfAborted(signal);
+    if (typeof runtime.execute !== 'function' || !capabilities.includes(capability)) throw new DrawMotiveError('UNSUPPORTED_CAPABILITY', `Runtime does not support ${format} rendering`);
+    return instance.mutate(async () => {
+      throwIfAborted(signal);
+      let response;
+      try { response = await runtime.execute(JSON.stringify(request), { signal }); }
+      catch (cause) {
+        throwIfAborted(signal);
+        if (cause instanceof DrawMotiveError || cause?.name === 'AbortError') throw cause;
+        throw new DrawMotiveError('RUNTIME_FAILED', `${format} rendering could not execute`, { cause });
+      }
+      throwIfAborted(signal);
+      return decode(response, encoding);
+    });
+  };
   return Object.assign(instance, {
     info,
     async renderPng(source, callOptions = {}) {
-      if (instance.state !== 'ready') throw new DrawMotiveError('INSTANCE_DISPOSED', 'The runtime instance is disposing or disposed');
-      const { request, encoding, signal } = normalizeRenderOptions(source, callOptions);
-      throwIfAborted(signal);
-      if (typeof runtime.execute !== 'function' || !capabilities.includes('textgraph-render-v1')) throw new DrawMotiveError('UNSUPPORTED_CAPABILITY', 'Runtime does not support PNG rendering');
-      return instance.mutate(async () => {
-        throwIfAborted(signal);
-        let response;
-        try { response = await runtime.execute(JSON.stringify(request), { signal }); }
-        catch (cause) {
-          throwIfAborted(signal);
-          if (cause instanceof DrawMotiveError || cause?.name === 'AbortError') throw cause;
-          throw new DrawMotiveError('RUNTIME_FAILED', 'PNG rendering could not execute', { cause });
-        }
-        throwIfAborted(signal);
-        return decodeRender(response, encoding);
-      });
+      return render(source, callOptions, normalizeRenderOptions, decodeRender, 'textgraph-render-v1', 'PNG');
+    },
+    async renderSvg(source, callOptions = {}) {
+      return render(source, callOptions, normalizeSvgOptions, decodeSvgRender, 'textgraph-render-svg-v1', 'SVG');
     },
     async validate(source, callOptions = {}) {
       if (instance.state !== 'ready') throw new DrawMotiveError('INSTANCE_DISPOSED', 'The runtime instance is disposing or disposed');

package/src/runtime/dotnet.js

@@ -1,6 +1,6 @@
 import { createRuntimeAssetPlan } from './shared.js';
 import { DrawMotiveError } from './errors.js';
-import { validateManifest, validateBootConfig, validationCapability, renderingCapability, isRuntimeAsset } from './manifest.js';
+import { validateManifest, validateBootConfig, validationCapability, renderingCapability, svgRenderingCapability, supportsRendering, isRuntimeAsset } from './manifest.js';
 import { throwIfAborted } from './lifecycle.js';
 import { readVerifiedAsset } from './integrity.js';
 import { createRenderingExecutor } from './render-resources.js';
@@ -69,8 +69,10 @@ export async function startTextGraphRuntime(options, manifest, readAsset) {
       throw new DrawMotiveError('ABI_MISMATCH', 'Bridge and manifest disagree');
     }
     if (!Array.isArray(info.capabilities) || !info.capabilities.includes(validationCapability)) throw new DrawMotiveError('UNSUPPORTED_CAPABILITY', 'Bridge does not implement validation');
-    const renders = manifest.capabilities.includes(renderingCapability);
-    if (renders && !info.capabilities.includes(renderingCapability)) throw new DrawMotiveError('UNSUPPORTED_CAPABILITY', 'Bridge does not implement rendering');
+    const renders = supportsRendering(manifest.capabilities);
+    for (const capability of [renderingCapability, svgRenderingCapability]) {
+      if (manifest.capabilities.includes(capability) && !info.capabilities.includes(capability)) throw new DrawMotiveError('UNSUPPORTED_CAPABILITY', 'Bridge does not implement rendering');
+    }
     if (manifest.capabilities.includes(fontCapability) && !info.capabilities.includes(fontCapability)) throw new DrawMotiveError('UNSUPPORTED_CAPABILITY', 'Bridge does not implement lazy fonts');
     if (renders && typeof bridge[manifest.bridge.execute] !== 'function') throw new DrawMotiveError('ABI_MISMATCH', 'Rendering bridge export is missing');
     return createBridgeRuntime({ manifest, options, readAsset, bridge, info });
@@ -83,7 +85,7 @@ export async function startTextGraphRuntime(options, manifest, readAsset) {
 
 /** Owns managed bridge resources; the instance queue drains calls before invoking disposal. */
 export function createBridgeRuntime({ manifest, options, readAsset, bridge, info }) {
-  const renders = manifest.capabilities.includes(renderingCapability);
+  const renders = supportsRendering(manifest.capabilities);
   return {
     // A bridge may support operations intentionally omitted by the selected
     // manifest; advertise only the intersection that this loader exposes.

package/src/runtime/manifest.js

@@ -2,6 +2,12 @@ import { DrawMotiveError } from './errors.js';
 
 export const validationCapability = 'textgraph-validate-v1';
 export const renderingCapability = 'textgraph-render-v1';
+export const svgRenderingCapability = 'textgraph-render-svg-v1';
+
+/** Both image capabilities require the same managed executor and rendering resources. */
+export function supportsRendering(capabilities) {
+  return [renderingCapability, svgRenderingCapability].some(capability => capabilities.includes(capability));
+}
 
 /** Only native runtime formats belong to startup; fonts, themes and licenses are separate assets. */
 export function isRuntimeAsset(asset) {
@@ -43,7 +49,7 @@ export function validateManifest(manifest) {
       || manifest.bridge?.type !== 'DrawMotive.TextGraph.Bridge.Program' || manifest.bridge?.info !== 'GetRuntimeInfo'
       || manifest.bridge?.validate !== 'Validate') invalid();
   if (manifest.bridge.execute !== undefined && manifest.bridge.execute !== 'Execute') invalid();
-  if (manifest.capabilities.includes(renderingCapability) && (!manifest.rendering || manifest.bridge.execute !== 'Execute')) invalid();
+  if (supportsRendering(manifest.capabilities) && (!manifest.rendering || manifest.bridge.execute !== 'Execute')) invalid();
   if (manifest.rendering !== undefined) {
     const rendering = manifest.rendering;
     if (!rendering || !paths.has(rendering.theme) || !rendering.theme.endsWith('.css')

package/src/runtime/rendering.js

@@ -2,20 +2,35 @@ import { DrawMotiveError } from './errors.js';
 import { decodeDiagnostics, validateSignal } from './validation.js';
 
 const stages = ['parse', 'semantic', 'layout', 'render', 'font'];
+const invalid = message => { throw new DrawMotiveError('INVALID_ARGUMENT', message); };
 
-/** Normalize export settings before queuing; native receives only the render contract. */
-export function normalizeRenderOptions(source, options) {
-  const invalid = message => { throw new DrawMotiveError('INVALID_ARGUMENT', message); };
+/** Both export formats share source, logical padding, language and cancellation semantics. */
+function normalizeCommonOptions(source, options) {
   if (typeof source !== 'string' || !options || typeof options !== 'object' || Array.isArray(options)) invalid('Rendering requires a source string and options object');
-  const { encoding = 'bytes', scale = 1, padding = 10, maxWidth, signal, language } = options;
+  const { padding = 10, signal, language } = options;
   if (language !== undefined && (typeof language !== 'string' || !/^[a-z]{2,8}(?:-[A-Za-z0-9]+)*$/.test(language))) invalid('language must be a language tag');
+  // The native geometry contract uses float32; reject values lost at that boundary.
+  if (!Number.isFinite(padding) || !Number.isFinite(Math.fround(padding)) || padding < 0) invalid('padding must be non-negative and representable as a finite float32');
+  validateSignal(signal);
+  return { padding, signal, request: { protocolVersion: 1, operation: 'render', source, ...(language === undefined ? {} : { language }) } };
+}
+
+/** Normalize export settings before queuing; native receives only the render contract. */
+export function normalizeRenderOptions(source, options) {
+  const { padding, signal, request } = normalizeCommonOptions(source, options);
+  const { encoding = 'bytes', scale = 1, maxWidth } = options;
   if (!['bytes', 'base64'].includes(encoding)) invalid('encoding must be bytes or base64');
   // The native geometry contract uses float32; reject values lost at that boundary.
   if (!Number.isFinite(scale) || !Number.isFinite(Math.fround(scale)) || Math.fround(scale) <= 0) invalid('scale must be positive and representable as a finite float32');
-  if (!Number.isFinite(padding) || !Number.isFinite(Math.fround(padding)) || padding < 0) invalid('padding must be non-negative and representable as a finite float32');
   if (maxWidth !== undefined && (!Number.isSafeInteger(maxWidth) || maxWidth <= 0)) invalid('maxWidth must be a positive integer');
-  validateSignal(signal);
-  return { encoding, signal, request: { protocolVersion: 1, operation: 'render', source, ...(language === undefined ? {} : { language }), export: { format: 'png', scale, padding, ...(maxWidth === undefined ? {} : { maxWidth }) } } };
+  return { encoding, signal, request: { ...request, export: { format: 'png', scale, padding, ...(maxWidth === undefined ? {} : { maxWidth }) } } };
+}
+
+/** SVG accepts only logical export settings; PNG density and encoding have no vector meaning. */
+export function normalizeSvgOptions(source, options) {
+  const { padding, signal, request } = normalizeCommonOptions(source, options);
+  if (Reflect.ownKeys(options).some(key => !['padding', 'language', 'signal'].includes(key))) invalid('Unknown SVG rendering option');
+  return { signal, request: { ...request, export: { format: 'svg', padding } } };
 }
 
 /** Accept canonical base64 only; platform atob implementations otherwise tolerate corruption. */
@@ -59,6 +74,33 @@ export function decodeRender(json, encoding) {
   }
 }
 
+/** Check the vector document boundary without requiring a DOM or loading external XML resources. */
+export function decodeSvgRender(json) {
+  try {
+    const value = JSON.parse(json);
+    if (value?.protocolVersion !== 1 || typeof value.success !== 'boolean') throw new Error('Invalid envelope');
+    const diagnostics = decodeDiagnostics(value.diagnostics, stages);
+    if (value.success === diagnostics.some(item => item.severity === 'error')) throw new Error('Inconsistent success');
+    if (!value.success) {
+      if (['svg', 'displayWidth', 'displayHeight', 'png', 'width', 'height'].some(key => Object.hasOwn(value, key))) throw new Error('Failure contains image data');
+      return Object.freeze({ success: false, diagnostics });
+    }
+    if (![value.displayWidth, value.displayHeight].every(n => Number.isFinite(n) && n > 0)) throw new Error('Invalid display dimensions');
+    // This is an envelope check, not a general XML parser: the trusted native
+    // exporter owns element syntax. Require its SVG root, namespace and complete document.
+    const document = typeof value.svg === 'string' && /^(?:<\?xml\b[^?]*\?>\s*)?<svg(?=\s|\/?>)([^>]*?)(?:\/>|>[\s\S]*<\/svg\s*>)$/.exec(value.svg.trim());
+    if (!document) throw new Error('Invalid SVG document');
+    // Consume complete attribute values so namespace-like text inside another
+    // quoted attribute cannot impersonate the root namespace.
+    const attributes = [...document[1].matchAll(/(?:^|\s)([A-Za-z_:][A-Za-z0-9_.:-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)];
+    const namespaces = attributes.filter(attribute => attribute[1] === 'xmlns');
+    if (namespaces.length !== 1 || (namespaces[0][2] ?? namespaces[0][3]) !== 'http://www.w3.org/2000/svg') throw new Error('Invalid SVG namespace');
+    return Object.freeze({ success: true, svg: value.svg, displayWidth: value.displayWidth, displayHeight: value.displayHeight, diagnostics });
+  } catch (cause) {
+    throw new DrawMotiveError('INVALID_RESPONSE', 'The SVG rendering response violates protocol 1', { cause });
+  }
+}
+
 /** Resource setup and disposal failures are operational, separate from diagram diagnostics. */
 export function decodeConfiguration(json, operation = 'configuration') {
   let value;