@ansight/pencil-runtime 0.0.0-stage → 1.9.0

package/LICENSE

@@ -0,0 +1,166 @@
+# PolyForm Shield License 1.0.0
+
+<https://polyformproject.org/licenses/shield/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose.  However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software.  Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncompete
+
+Any purpose is a permitted purpose, except for providing any
+product that competes with the software or any product the
+licensor or any of its affiliates provides using the software.
+
+## Competition
+
+Goods and services compete even when they provide functionality
+through different kinds of interfaces or for different technical
+platforms.  Applications can compete with services, libraries
+with plugins, frameworks with development tools, and so on,
+even if they're written in different programming languages
+or for different computer architectures.  Goods and services
+compete even when provided free of charge.  If you market a
+product as a practical substitute for the software or another
+product, it definitely competes.
+
+## New Products
+
+If you are using the software to provide a product that does
+not compete, but the licensor or any of its affiliates brings
+your product into competition by providing a new version of
+the software or another product using the software, you may
+continue using versions of the software available under these
+terms beforehand to provide your competing product, but not
+any later versions.
+
+## Discontinued Products
+
+You may begin using the software to compete with a product
+or service that the licensor or any of its affiliates has
+stopped providing, unless the licensor includes a plain-text
+line beginning with `Licensor Line of Business:` with the
+software that mentions that line of business.  For example:
+
+> Licensor Line of Business: YoyodyneCMS Content Management
+System (http://example.com/cms)
+
+## Sales of Business
+
+If the licensor or any of its affiliates sells a line of
+business developing the software or using the software
+to provide a product, the buyer can also enforce
+[Noncompete](#noncompete) for that product.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+A **product** can be a good or service, or a combination
+of them.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+its affiliates.
+
+**Affiliates** means the other organizations than an
+organization has control over, is under the control of, or is
+under common control with.
+
+**Control** means ownership of substantially all the assets of
+an entity, or the power to direct its management and policies
+by vote, contract, or otherwise.  Control can be direct or
+indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.
+
+Required Notice: Copyright (c) 2026 Ansight, Inc. (https://www.ansight.ai)

package/README.md

@@ -1,3 +1,7 @@
-# Temporary Holding Version
+# @ansight/pencil-runtime
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Optional Pencil support for iOS Simulator.
+
+[Documentation: integration, playback, capture, compatibility and package updates](https://www.ansight.ai/docs/sdk/pencil).
+
+These packages are currently local and unpublished.

package/index.d.ts

@@ -0,0 +1,26 @@
+export interface PenSample { phase: 'down'|'move'|'up'|'cancel'|'hoverEnter'|'hoverMove'|'hoverExit'; x: number; y: number; pressure: number; altitudeRadians: number; azimuthRadians: number; rollRadians: number; distance: number; }
+export interface SurfaceGeometry { x: number; y: number; width: number; height: number; viewportWidth: number; viewportHeight: number; scale: number; }
+export interface PencilAdapter {
+  validate?(samples: PenSample[]): void;
+  snapshot(): SurfaceGeometry | Promise<SurfaceGeometry>;
+  hitTest(point: {x: number; y: number}): boolean | Promise<boolean>;
+  dispatch(sample: PenSample, geometry: SurfaceGeometry, pointerId: number): void | Promise<void>;
+  finish?(pointerId: number): void | Promise<void>;
+  isBusy?(): boolean;
+  onError?(error: unknown): void;
+}
+export function createPencilRuntime(options: {
+  capture(sample: PenSample, geometry: SurfaceGeometry, pointerId: number): Promise<void>;
+  checkPlayback(): Promise<void>; timeoutMs?: number;
+}): {
+  definition: { id: string; name: string; category: string; policy: 'write'; description: string; argumentsSchema: Record<string, unknown> };
+  bindSurface(id: string, adapter: PencilAdapter): () => Promise<void>;
+  handle(args: {command: string}): Promise<{success: true; result?: unknown} | {success: false; message: string; errorCode?: string}>;
+};
+export function pointerProperties(sample: PenSample, geometry: SurfaceGeometry, pointerId: number): {
+  pointerId: number; pointerType: string; isPrimary: boolean; clientX: number; clientY: number;
+  pageX: number; pageY: number; pressure: number; width: number; height: number;
+  buttons: number; button: number; tiltX: number; tiltY: number; twist: number;
+  altitudeAngle: number; azimuthAngle: number; ansightPencil: PenSample & {inputSource: string};
+};
+export function validateSequence(samples: unknown[]): PenSample[];

package/index.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const phases = ['down', 'move', 'up', 'cancel', 'hoverEnter', 'hoverMove', 'hoverExit'];
+const fields = ['phase', 'x', 'y', 'pressure', 'altitudeRadians', 'azimuthRadians', 'rollRadians', 'distance'];
+function normalize(value) {
+  if (!value || typeof value !== 'object' || !phases.includes(value.phase)) throw new Error('Invalid Pencil sample.');
+  const sample = { pressure: 0, altitudeRadians: Math.PI / 2, azimuthRadians: 0, rollRadians: 0, distance: 0, ...value };
+  if (Object.keys(sample).some(key => !fields.includes(key))) throw new Error('Unknown Pencil sample field.');
+  for (const key of fields.slice(1)) if (!Number.isFinite(sample[key])) throw new Error('Pencil values must be finite.');
+  for (const key of ['x', 'y', 'pressure', 'distance']) if (sample[key] < 0 || sample[key] > 1) throw new Error(`${key} must be between 0 and 1.`);
+  if (sample.altitudeRadians < 0 || sample.altitudeRadians > Math.PI / 2) throw new Error('Invalid altitude.');
+  if (!['down', 'move'].includes(sample.phase) && sample.pressure !== 0) throw new Error('Non-contact pressure must be zero.');
+  return Object.fromEntries(fields.map(key => [key, sample[key]]));
+}
+function validateSequence(values) {
+  if (!Array.isArray(values) || values.length < 2 || values.length > 2000) throw new Error('Supply 2..2000 samples.');
+  let touching = false, hovering = false;
+  return values.map(normalize).map((sample, index, all) => {
+    const p = sample.phase;
+    if ((p === 'down' && touching) || (['move', 'up', 'cancel'].includes(p) && !touching)
+      || (p === 'hoverEnter' && (touching || hovering)) || (['hoverMove', 'hoverExit'].includes(p) && (!hovering || touching))) throw new Error('Invalid Pencil sequence.');
+    if (p === 'down') { touching = true; hovering = false; }
+    if (p === 'up') { touching = false; hovering = true; }
+    if (p === 'hoverEnter') hovering = true;
+    if (['cancel', 'hoverExit'].includes(p)) { touching = false; hovering = false; }
+    if (index === all.length - 1 && touching) throw new Error('End contact with up or cancel.');
+    return sample;
+  });
+}
+function geometry(value) {
+  if (!value || !['x', 'y', 'width', 'height', 'viewportWidth', 'viewportHeight', 'scale'].every(key => Number.isFinite(value[key]))) throw new Error('Surface is not laid out.');
+  if (['width', 'height', 'viewportWidth', 'viewportHeight', 'scale'].some(key => value[key] <= 0)) throw new Error('Surface has no visible area.');
+  return Object.fromEntries(['x', 'y', 'width', 'height', 'viewportWidth', 'viewportHeight', 'scale'].map(key => [key, value[key]]));
+}
+function point(sample, rect) { return { x: sample.x * rect.viewportWidth, y: sample.y * rect.viewportHeight }; }
+function inside(sample, rect) {
+  const p = point(sample, rect);
+  return p.x >= rect.x && p.y >= rect.y && p.x < rect.x + rect.width && p.y < rect.y + rect.height;
+}
+
+const definition = {
+  id: 'ui.simulate_pen_framework', name: 'Play Pencil input on a registered framework surface', category: 'ui', policy: 'write',
+  description: 'Explicit SDK playback; invokes only a registered framework surface. Does not inject HID or install UIKit hooks.',
+  argumentsSchema: { type: 'object', required: ['command'], additionalProperties: false, properties: { command: { type: 'string' } } },
+};
+
+function createPencilRuntime({ capture, checkPlayback, timeoutMs = 35000 }) {
+  const surfaces = new Map();
+  let active = null, handling = false, nextPointer = 1900000000;
+  async function finish(run = active) {
+    if (!run || active !== run) return;
+    active = null;
+    clearTimeout(run.timer);
+    const last = run.last;
+    try {
+      if (last && (run.touching || run.hovering)) {
+        const terminal = { ...last, phase: run.touching ? 'cancel' : 'hoverExit', pressure: 0 };
+        try { await run.adapter.dispatch(terminal, run.rect, run.pointerId); }
+        finally { await capture(terminal, run.rect, run.pointerId); }
+      }
+    } finally { await run.adapter.finish?.(run.pointerId); }
+  }
+  function bindSurface(id, adapter) {
+    if (typeof id !== 'string' || !id.trim() || surfaces.has(id)) throw new Error('Pencil surface IDs must be unique and nonempty.');
+    surfaces.set(id, adapter);
+    return async () => {
+      if (surfaces.get(id) !== adapter) return;
+      surfaces.delete(id);
+      if (active?.adapter === adapter) await finish();
+    };
+  }
+  async function execute(command) {
+    if (!command || typeof command.runId !== 'string' || !command.runId.trim()) throw new Error('A run ID is required.');
+    if (command.action === 'prepare') {
+      if (active) throw new Error('A Pencil run is already active.');
+      const adapter = surfaces.get(command.target);
+      if (!adapter) throw new Error('Pencil target is not mounted or registered.');
+      const samples = validateSequence(command.samples);
+      adapter.validate?.(samples);
+      await checkPlayback();
+      const rect = geometry(await adapter.snapshot());
+      if (adapter.isBusy?.()) throw new Error('The surface has active real input.');
+      for (const sample of samples) if (!inside(sample, rect) || !(await adapter.hitTest(point(sample, rect)))) throw new Error('A sample does not hit the selected surface.');
+      if (surfaces.get(command.target) !== adapter || adapter.isBusy?.()) throw new Error('Surface detached or received real input during preparation.');
+      const run = { adapter, target: command.target, id: command.runId, samples, rect, index: 0, pointerId: nextPointer++, touching: false, hovering: false, last: null };
+      active = run;
+      run.timer = setTimeout(() => { finish(run).catch(error => adapter.onError?.(error)); }, timeoutMs);
+      run.timer.unref?.();
+      return { protocolVersion: 1, delivery: 'framework' };
+    }
+    if (!active && command.action === 'finish') return {};
+    if (!active || active.id !== command.runId) throw new Error('No matching Pencil run.');
+    const run = active;
+    if (command.action === 'finish') { await finish(run); return {}; }
+    if (command.action !== 'sample') throw new Error('Unknown Pencil action.');
+    try {
+      const sample = normalize(command.sample);
+      if (JSON.stringify(sample) !== JSON.stringify(run.samples[run.index])) throw new Error('Sample differs from the prepared sequence.');
+      if (surfaces.get(run.target) !== run.adapter || run.adapter.isBusy?.()) throw new Error('Surface detached or received real input.');
+      if (JSON.stringify(geometry(await run.adapter.snapshot())) !== JSON.stringify(run.rect) || !(await run.adapter.hitTest(point(sample, run.rect)))) throw new Error('Surface moved, resized or became covered.');
+      await checkPlayback();
+      // Native checks yield to the app; disposal or lease expiry can happen while awaiting them.
+      if (active !== run || surfaces.get(run.target) !== run.adapter || run.adapter.isBusy?.()) throw new Error('Pencil run ended or the surface changed during validation.');
+      run.last = sample;
+      run.touching = ['down', 'move'].includes(sample.phase);
+      run.hovering = ['up', 'hoverEnter', 'hoverMove'].includes(sample.phase);
+      await run.adapter.dispatch(sample, run.rect, run.pointerId);
+      await capture(sample, run.rect, run.pointerId);
+      if (active !== run) throw new Error('Pencil run ended during delivery.');
+      run.index++;
+      return { delivered: true, sampleIndex: run.index - 1 };
+    } catch (error) { await finish(run); throw error; }
+  }
+  async function handle(args) {
+    if (handling) return { success: false, errorCode: 'pen_busy', message: 'Another Pencil command is executing.' };
+    handling = true;
+    try {
+      const command = JSON.parse(args.command);
+      return { success: true, result: await execute(command) };
+    } catch (error) { return { success: false, errorCode: 'pen_framework_failed', message: String(error.message || error) }; }
+    finally { handling = false; }
+  }
+  return { definition, bindSurface, handle };
+}
+
+function pointerProperties(sample, rect, pointerId) {
+  const p = point(sample, rect), contact = ['down', 'move'].includes(sample.phase);
+  const altitude = sample.altitudeRadians, azimuth = sample.azimuthRadians;
+  const degrees = 180 / Math.PI;
+  return { pointerId, pointerType: 'pen', isPrimary: true, clientX: p.x, clientY: p.y,
+    pageX: p.x, pageY: p.y, pressure: sample.pressure, width: 1, height: 1,
+    buttons: contact ? 1 : 0, button: ['down', 'up'].includes(sample.phase) ? 0 : -1,
+    tiltX: Math.atan2(Math.cos(azimuth) * Math.cos(altitude), Math.sin(altitude)) * degrees,
+    tiltY: Math.atan2(Math.sin(azimuth) * Math.cos(altitude), Math.sin(altitude)) * degrees,
+    twist: ((sample.rollRadians * degrees % 360) + 360) % 360,
+    altitudeAngle: altitude, azimuthAngle: azimuth,
+    ansightPencil: Object.freeze({ ...sample, inputSource: 'simulator-sdk-framework' }) };
+}
+module.exports = { createPencilRuntime, pointerProperties, validateSequence };

package/index.mjs

@@ -0,0 +1,139 @@
+'use strict';
+
+const phases = ['down', 'move', 'up', 'cancel', 'hoverEnter', 'hoverMove', 'hoverExit'];
+const fields = ['phase', 'x', 'y', 'pressure', 'altitudeRadians', 'azimuthRadians', 'rollRadians', 'distance'];
+function normalize(value) {
+  if (!value || typeof value !== 'object' || !phases.includes(value.phase)) throw new Error('Invalid Pencil sample.');
+  const sample = { pressure: 0, altitudeRadians: Math.PI / 2, azimuthRadians: 0, rollRadians: 0, distance: 0, ...value };
+  if (Object.keys(sample).some(key => !fields.includes(key))) throw new Error('Unknown Pencil sample field.');
+  for (const key of fields.slice(1)) if (!Number.isFinite(sample[key])) throw new Error('Pencil values must be finite.');
+  for (const key of ['x', 'y', 'pressure', 'distance']) if (sample[key] < 0 || sample[key] > 1) throw new Error(`${key} must be between 0 and 1.`);
+  if (sample.altitudeRadians < 0 || sample.altitudeRadians > Math.PI / 2) throw new Error('Invalid altitude.');
+  if (!['down', 'move'].includes(sample.phase) && sample.pressure !== 0) throw new Error('Non-contact pressure must be zero.');
+  return Object.fromEntries(fields.map(key => [key, sample[key]]));
+}
+function validateSequence(values) {
+  if (!Array.isArray(values) || values.length < 2 || values.length > 2000) throw new Error('Supply 2..2000 samples.');
+  let touching = false, hovering = false;
+  return values.map(normalize).map((sample, index, all) => {
+    const p = sample.phase;
+    if ((p === 'down' && touching) || (['move', 'up', 'cancel'].includes(p) && !touching)
+      || (p === 'hoverEnter' && (touching || hovering)) || (['hoverMove', 'hoverExit'].includes(p) && (!hovering || touching))) throw new Error('Invalid Pencil sequence.');
+    if (p === 'down') { touching = true; hovering = false; }
+    if (p === 'up') { touching = false; hovering = true; }
+    if (p === 'hoverEnter') hovering = true;
+    if (['cancel', 'hoverExit'].includes(p)) { touching = false; hovering = false; }
+    if (index === all.length - 1 && touching) throw new Error('End contact with up or cancel.');
+    return sample;
+  });
+}
+function geometry(value) {
+  if (!value || !['x', 'y', 'width', 'height', 'viewportWidth', 'viewportHeight', 'scale'].every(key => Number.isFinite(value[key]))) throw new Error('Surface is not laid out.');
+  if (['width', 'height', 'viewportWidth', 'viewportHeight', 'scale'].some(key => value[key] <= 0)) throw new Error('Surface has no visible area.');
+  return Object.fromEntries(['x', 'y', 'width', 'height', 'viewportWidth', 'viewportHeight', 'scale'].map(key => [key, value[key]]));
+}
+function point(sample, rect) { return { x: sample.x * rect.viewportWidth, y: sample.y * rect.viewportHeight }; }
+function inside(sample, rect) {
+  const p = point(sample, rect);
+  return p.x >= rect.x && p.y >= rect.y && p.x < rect.x + rect.width && p.y < rect.y + rect.height;
+}
+
+const definition = {
+  id: 'ui.simulate_pen_framework', name: 'Play Pencil input on a registered framework surface', category: 'ui', policy: 'write',
+  description: 'Explicit SDK playback; invokes only a registered framework surface. Does not inject HID or install UIKit hooks.',
+  argumentsSchema: { type: 'object', required: ['command'], additionalProperties: false, properties: { command: { type: 'string' } } },
+};
+
+function createPencilRuntime({ capture, checkPlayback, timeoutMs = 35000 }) {
+  const surfaces = new Map();
+  let active = null, handling = false, nextPointer = 1900000000;
+  async function finish(run = active) {
+    if (!run || active !== run) return;
+    active = null;
+    clearTimeout(run.timer);
+    const last = run.last;
+    try {
+      if (last && (run.touching || run.hovering)) {
+        const terminal = { ...last, phase: run.touching ? 'cancel' : 'hoverExit', pressure: 0 };
+        try { await run.adapter.dispatch(terminal, run.rect, run.pointerId); }
+        finally { await capture(terminal, run.rect, run.pointerId); }
+      }
+    } finally { await run.adapter.finish?.(run.pointerId); }
+  }
+  function bindSurface(id, adapter) {
+    if (typeof id !== 'string' || !id.trim() || surfaces.has(id)) throw new Error('Pencil surface IDs must be unique and nonempty.');
+    surfaces.set(id, adapter);
+    return async () => {
+      if (surfaces.get(id) !== adapter) return;
+      surfaces.delete(id);
+      if (active?.adapter === adapter) await finish();
+    };
+  }
+  async function execute(command) {
+    if (!command || typeof command.runId !== 'string' || !command.runId.trim()) throw new Error('A run ID is required.');
+    if (command.action === 'prepare') {
+      if (active) throw new Error('A Pencil run is already active.');
+      const adapter = surfaces.get(command.target);
+      if (!adapter) throw new Error('Pencil target is not mounted or registered.');
+      const samples = validateSequence(command.samples);
+      adapter.validate?.(samples);
+      await checkPlayback();
+      const rect = geometry(await adapter.snapshot());
+      if (adapter.isBusy?.()) throw new Error('The surface has active real input.');
+      for (const sample of samples) if (!inside(sample, rect) || !(await adapter.hitTest(point(sample, rect)))) throw new Error('A sample does not hit the selected surface.');
+      if (surfaces.get(command.target) !== adapter || adapter.isBusy?.()) throw new Error('Surface detached or received real input during preparation.');
+      const run = { adapter, target: command.target, id: command.runId, samples, rect, index: 0, pointerId: nextPointer++, touching: false, hovering: false, last: null };
+      active = run;
+      run.timer = setTimeout(() => { finish(run).catch(error => adapter.onError?.(error)); }, timeoutMs);
+      run.timer.unref?.();
+      return { protocolVersion: 1, delivery: 'framework' };
+    }
+    if (!active && command.action === 'finish') return {};
+    if (!active || active.id !== command.runId) throw new Error('No matching Pencil run.');
+    const run = active;
+    if (command.action === 'finish') { await finish(run); return {}; }
+    if (command.action !== 'sample') throw new Error('Unknown Pencil action.');
+    try {
+      const sample = normalize(command.sample);
+      if (JSON.stringify(sample) !== JSON.stringify(run.samples[run.index])) throw new Error('Sample differs from the prepared sequence.');
+      if (surfaces.get(run.target) !== run.adapter || run.adapter.isBusy?.()) throw new Error('Surface detached or received real input.');
+      if (JSON.stringify(geometry(await run.adapter.snapshot())) !== JSON.stringify(run.rect) || !(await run.adapter.hitTest(point(sample, run.rect)))) throw new Error('Surface moved, resized or became covered.');
+      await checkPlayback();
+      // Native checks yield to the app; disposal or lease expiry can happen while awaiting them.
+      if (active !== run || surfaces.get(run.target) !== run.adapter || run.adapter.isBusy?.()) throw new Error('Pencil run ended or the surface changed during validation.');
+      run.last = sample;
+      run.touching = ['down', 'move'].includes(sample.phase);
+      run.hovering = ['up', 'hoverEnter', 'hoverMove'].includes(sample.phase);
+      await run.adapter.dispatch(sample, run.rect, run.pointerId);
+      await capture(sample, run.rect, run.pointerId);
+      if (active !== run) throw new Error('Pencil run ended during delivery.');
+      run.index++;
+      return { delivered: true, sampleIndex: run.index - 1 };
+    } catch (error) { await finish(run); throw error; }
+  }
+  async function handle(args) {
+    if (handling) return { success: false, errorCode: 'pen_busy', message: 'Another Pencil command is executing.' };
+    handling = true;
+    try {
+      const command = JSON.parse(args.command);
+      return { success: true, result: await execute(command) };
+    } catch (error) { return { success: false, errorCode: 'pen_framework_failed', message: String(error.message || error) }; }
+    finally { handling = false; }
+  }
+  return { definition, bindSurface, handle };
+}
+
+function pointerProperties(sample, rect, pointerId) {
+  const p = point(sample, rect), contact = ['down', 'move'].includes(sample.phase);
+  const altitude = sample.altitudeRadians, azimuth = sample.azimuthRadians;
+  const degrees = 180 / Math.PI;
+  return { pointerId, pointerType: 'pen', isPrimary: true, clientX: p.x, clientY: p.y,
+    pageX: p.x, pageY: p.y, pressure: sample.pressure, width: 1, height: 1,
+    buttons: contact ? 1 : 0, button: ['down', 'up'].includes(sample.phase) ? 0 : -1,
+    tiltX: Math.atan2(Math.cos(azimuth) * Math.cos(altitude), Math.sin(altitude)) * degrees,
+    tiltY: Math.atan2(Math.sin(azimuth) * Math.cos(altitude), Math.sin(altitude)) * degrees,
+    twist: ((sample.rollRadians * degrees % 360) + 360) % 360,
+    altitudeAngle: altitude, azimuthAngle: azimuth,
+    ansightPencil: Object.freeze({ ...sample, inputSource: 'simulator-sdk-framework' }) };
+}
+export { createPencilRuntime, pointerProperties, validateSequence };

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@ansight/pencil-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.9.0",
+  "description": "Scoped playback lifecycle for optional Ansight Pencil framework adapters.",
+  "main": "index.js",
+  "module": "index.mjs",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js"
+    }
+  },
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.mjs",
+    "index.d.ts",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "scripts": {
+    "build": "node build.mjs",
+    "prepack": "npm run build",
+    "test": "npm run build && node --test test/*.test.js",
+    "check": "npm test"
+  }
+}