@flighthq/midi 0.4.1-next.515.b0834fe

package/dist/midiSubscription.js

@@ -0,0 +1,188 @@
+import { createEntity } from '@flighthq/entity/contract';
+import { clearSignal, createSignal, emitSignal } from '@flighthq/signals/contract';
+import { getMidiAccessResourceState, getMidiPortResourceState } from './midiResource';
+export function attachMidiAccessStateSubscription(access, subscription) {
+    const state = getMidiAccessResourceState(access);
+    if (state === undefined || state.disposed)
+        return Promise.resolve(attachFailure());
+    return attachMidiSubscription(subscription, state.subscriptions, (listener) => state.operations.attachStateChange(listener), (port) => {
+        state.knownPorts.add(port);
+        emitSignal(subscription.onMidiAccessStateChange, port);
+    });
+}
+export function attachMidiInputMessageSubscription(input, subscription) {
+    const state = getMidiPortResourceState(input);
+    if (state === undefined || state.kind !== 'input' || state.disposed)
+        return Promise.resolve(attachFailure());
+    return attachMidiSubscription(subscription, state.messageSubscriptions, (listener) => state.operations.attachMessage(listener), (data, timestamp) => emitSignal(subscription.onMidiInputMessage, { data: new Uint8Array(data), timestamp }));
+}
+export function attachMidiPortStateSubscription(port, subscription) {
+    const state = getMidiPortResourceState(port);
+    if (state === undefined || state.disposed)
+        return Promise.resolve(attachFailure());
+    return attachMidiSubscription(subscription, state.stateSubscriptions, (listener) => state.operations.attachStateChange(listener), () => emitSignal(subscription.onMidiPortStateChange, port));
+}
+export function createMidiAccessStateSubscription() {
+    return createMidiSubscription({ onMidiAccessStateChange: createSignal() });
+}
+export function createMidiInputMessageSubscription() {
+    return createMidiSubscription({ onMidiInputMessage: createSignal() });
+}
+export function createMidiPortStateSubscription() {
+    return createMidiSubscription({ onMidiPortStateChange: createSignal() });
+}
+export function detachMidiAccessStateSubscription(subscription) {
+    return detachMidiSubscription(subscription);
+}
+export function detachMidiInputMessageSubscription(subscription) {
+    return detachMidiSubscription(subscription);
+}
+export function detachMidiPortStateSubscription(subscription) {
+    return detachMidiSubscription(subscription);
+}
+export function disposeMidiAccessStateSubscription(subscription) {
+    return disposeMidiSubscription(subscription, subscription.onMidiAccessStateChange);
+}
+export function disposeMidiInputMessageSubscription(subscription) {
+    return disposeMidiSubscription(subscription, subscription.onMidiInputMessage);
+}
+export function disposeMidiPortStateSubscription(subscription) {
+    return disposeMidiSubscription(subscription, subscription.onMidiPortStateChange);
+}
+const subscriptionStates = new WeakMap();
+function createMidiSubscription(fields) {
+    const subscription = createEntity(fields);
+    subscriptionStates.set(subscription, {
+        attachment: null,
+        attaching: null,
+        disposeCompleted: false,
+        disposed: false,
+        generation: 0,
+        ownerSubscriptions: null,
+    });
+    return subscription;
+}
+async function attachMidiSubscription(subscription, ownerSubscriptions, attach, listener) {
+    const runtime = subscriptionStates.get(subscription);
+    if (runtime === undefined || runtime.disposed)
+        return attachFailure();
+    if (runtime.attaching !== null) {
+        runtime.generation++;
+        await runtime.attaching;
+        if (runtime.disposed)
+            return attachFailure();
+    }
+    if (runtime.attachment !== null) {
+        const detached = await detachMidiSubscription(subscription);
+        if (detached.reason === 'operation-failed') {
+            return { attachFailed: false, reason: 'operation-failed', releaseFailed: true };
+        }
+        if (runtime.disposed)
+            return attachFailure();
+    }
+    const generation = ++runtime.generation;
+    runtime.ownerSubscriptions = ownerSubscriptions;
+    ownerSubscriptions.add(subscription);
+    const attaching = performMidiAttach(subscription, runtime, generation, attach, listener);
+    runtime.attaching = attaching;
+    const outcome = await attaching;
+    if (runtime.attaching === attaching)
+        runtime.attaching = null;
+    return outcome;
+}
+async function performMidiAttach(subscription, runtime, generation, attach, listener) {
+    let pending;
+    try {
+        pending = attach(listener);
+    }
+    catch {
+        untrackMidiSubscription(subscription, runtime);
+        return attachFailure();
+    }
+    const outcome = await settleMidiAttach(pending);
+    if (outcome.reason === 'operation-failed') {
+        untrackMidiSubscription(subscription, runtime);
+        return { attachFailed: true, reason: 'operation-failed', releaseFailed: outcome.releaseFailed };
+    }
+    runtime.attachment = outcome.attachment;
+    if (runtime.disposed || runtime.generation !== generation) {
+        const released = await releaseTrackedMidiAttachment(subscription, runtime);
+        return released ? { reason: 'ok' } : { attachFailed: false, reason: 'operation-failed', releaseFailed: true };
+    }
+    return { reason: 'ok' };
+}
+async function detachMidiSubscription(subscription) {
+    const runtime = subscriptionStates.get(subscription);
+    if (runtime === undefined)
+        return { reason: 'not-attached' };
+    runtime.generation++;
+    let invalidatedAttach = false;
+    if (runtime.attaching !== null) {
+        const outcome = await runtime.attaching;
+        if (outcome.reason === 'operation-failed' && outcome.releaseFailed) {
+            return { reason: 'operation-failed', releaseFailed: true };
+        }
+        invalidatedAttach = outcome.reason === 'ok';
+    }
+    if (runtime.attachment === null)
+        return { reason: invalidatedAttach ? 'ok' : 'not-attached' };
+    if (!(await releaseTrackedMidiAttachment(subscription, runtime))) {
+        return { reason: 'operation-failed', releaseFailed: true };
+    }
+    return { reason: 'ok' };
+}
+async function disposeMidiSubscription(subscription, signal) {
+    const runtime = subscriptionStates.get(subscription);
+    if (runtime === undefined || runtime.disposeCompleted)
+        return { reason: 'already-disposed' };
+    runtime.disposed = true;
+    runtime.generation++;
+    let attachFailed = false;
+    let releaseFailed = false;
+    if (runtime.attaching !== null) {
+        const outcome = await runtime.attaching;
+        if (outcome.reason === 'operation-failed')
+            ({ attachFailed, releaseFailed } = outcome);
+    }
+    if (!releaseFailed) {
+        const detached = await detachMidiSubscription(subscription);
+        if (detached.reason === 'operation-failed')
+            releaseFailed = true;
+    }
+    clearSignal(signal);
+    if (attachFailed || releaseFailed)
+        return { attachFailed, reason: 'operation-failed', releaseFailed };
+    runtime.disposeCompleted = true;
+    return { reason: 'ok' };
+}
+function attachFailure() {
+    return { attachFailed: true, reason: 'operation-failed', releaseFailed: false };
+}
+async function releaseMidiAttachment(attachment) {
+    try {
+        return (await attachment.release()).reason === 'ok';
+    }
+    catch {
+        return false;
+    }
+}
+async function releaseTrackedMidiAttachment(subscription, runtime) {
+    if (runtime.attachment === null || !(await releaseMidiAttachment(runtime.attachment)))
+        return false;
+    runtime.attachment = null;
+    untrackMidiSubscription(subscription, runtime);
+    return true;
+}
+function untrackMidiSubscription(subscription, runtime) {
+    runtime.ownerSubscriptions?.delete(subscription);
+    runtime.ownerSubscriptions = null;
+}
+async function settleMidiAttach(pending) {
+    try {
+        return await pending;
+    }
+    catch {
+        return { reason: 'operation-failed', releaseFailed: false };
+    }
+}
+//# sourceMappingURL=midiSubscription.js.map

package/dist/midiSubscription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"midiSubscription.js","sourceRoot":"","sources":["../src/midiSubscription.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@flighthq/midi",
+  "version": "0.4.1-next.515.b0834fe",
+  "author": "Joshua Granick and other contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flighthq/flight.git",
+    "directory": "packages/midi"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/entity": "0.4.1-next.515.b0834fe",
+    "@flighthq/signals": "0.4.1-next.515.b0834fe",
+    "@flighthq/types": "0.4.1-next.515.b0834fe"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Explicit MIDI access, port resources, and lifecycle subscriptions",
+  "sideEffects": false
+}

package/src/midiAccess.test.ts

@@ -0,0 +1,130 @@
+import { createEntity } from '@flighthq/entity/contract';
+import { EntityRuntimeKey } from '@flighthq/types/contract';
+import { describe, expect, it, vi } from 'vitest';
+
+import * as midi from './contract';
+
+describe('createMidiAccessResource', () => {
+  it('creates an Entity whose provider operations stay outside its public fields', () => {
+    const createMidiAccessResource = requiredFunction('createMidiAccessResource');
+    const access = createMidiAccessResource({
+      attachStateChange: vi.fn(),
+      getInputPorts: () => [],
+      getOutputPorts: () => [],
+    }) as object;
+    expect(EntityRuntimeKey in access).toBe(true);
+    expect(Object.keys(access)).toEqual([]);
+  });
+});
+
+describe('disposeMidiAccess', () => {
+  it('is terminal and idempotent when no owned resources need release', async () => {
+    const access = createEmptyAccess();
+    const disposeMidiAccess = requiredFunction('disposeMidiAccess');
+    await expect(disposeMidiAccess(access)).resolves.toEqual({ reason: 'ok' });
+    await expect(disposeMidiAccess(access)).resolves.toEqual({ reason: 'already-disposed' });
+  });
+
+  it('attempts subscriptions and hotplug-only ports, then retries only failed releases', async () => {
+    const accessListener: { current: ((port: unknown) => void) | null } = { current: null };
+    const release = vi
+      .fn()
+      .mockResolvedValueOnce({ reason: 'operation-failed' })
+      .mockResolvedValueOnce({ reason: 'ok' });
+    const access = requiredFunction('createMidiAccessResource')({
+      attachStateChange: async (listener: (port: unknown) => void) => {
+        accessListener.current = listener;
+        return { attachment: createEntity({ release }), reason: 'ok' };
+      },
+      getInputPorts: () => [],
+      getOutputPorts: () => [],
+    });
+    const connection = { value: 'closed' };
+    const close = vi.fn(async () => {
+      connection.value = 'closed';
+    });
+    const port = requiredFunction('createMidiOutputPortResource')(
+      { id: 'hotplug', manufacturer: null, name: 'Hotplug', version: null },
+      {
+        attachStateChange: vi.fn(),
+        close,
+        getConnection: () => connection.value,
+        getState: () => 'connected',
+        open: async () => {
+          connection.value = 'open';
+        },
+        send: vi.fn(),
+      },
+    );
+    const subscription = requiredFunction('createMidiAccessStateSubscription')();
+    await requiredFunction('attachMidiAccessStateSubscription')(access, subscription);
+    accessListener.current?.(port);
+    await requiredFunction('openMidiPort')(port);
+
+    const disposeMidiAccess = requiredFunction('disposeMidiAccess');
+    await expect(disposeMidiAccess(access)).resolves.toEqual({
+      failures: [{ operation: 'state-subscription-release' }],
+      reason: 'operation-failed',
+    });
+    expect(close).toHaveBeenCalledOnce();
+    await expect(disposeMidiAccess(access)).resolves.toEqual({ reason: 'ok' });
+    expect(close).toHaveBeenCalledOnce();
+    expect(release).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('getMidiAccessInputPorts', () => {
+  it('returns the provider current stable input identities without routing through ids', () => {
+    const input = createEntity({ id: 'duplicate' });
+    const access = createAccess([input], []);
+    const getMidiAccessInputPorts = requiredFunction('getMidiAccessInputPorts');
+    expect(getMidiAccessInputPorts(access)).toEqual({ ports: [input], reason: 'ok' });
+    expect(getMidiAccessInputPorts(access)).toEqual({ ports: [input], reason: 'ok' });
+  });
+});
+
+describe('getMidiAccessOutputPorts', () => {
+  it('accepts an access with zero devices and preserves the provider output identities', () => {
+    const output = createEntity({ id: 'duplicate' });
+    const getMidiAccessOutputPorts = requiredFunction('getMidiAccessOutputPorts');
+    expect(getMidiAccessOutputPorts(createAccess([], []))).toEqual({ ports: [], reason: 'ok' });
+    expect(getMidiAccessOutputPorts(createAccess([], [output]))).toEqual({ ports: [output], reason: 'ok' });
+  });
+});
+
+describe('requestMidiAccess', () => {
+  it('retains accepted access and keeps denial, security restriction, and provider failure distinct', async () => {
+    const requestMidiAccess = requiredFunction('requestMidiAccess');
+    const access = createEmptyAccess();
+    const requestAccess = vi
+      .fn()
+      .mockResolvedValueOnce({ access, reason: 'accepted' })
+      .mockResolvedValueOnce({ reason: 'permission-denied' })
+      .mockResolvedValueOnce({ reason: 'security-restricted' })
+      .mockRejectedValueOnce(new Error('provider fault'));
+    const host = { midi: { access: createEntity({ requestAccess }) } };
+    await expect(requestMidiAccess(host)).resolves.toEqual({ access, reason: 'accepted' });
+    await expect(requestMidiAccess(host)).resolves.toEqual({ reason: 'permission-denied' });
+    await expect(requestMidiAccess(host)).resolves.toEqual({ reason: 'security-restricted' });
+    await expect(requestMidiAccess(host)).resolves.toEqual({ reason: 'operation-failed' });
+  });
+});
+
+function createAccess(inputs: readonly object[], outputs: readonly object[]): unknown {
+  return requiredFunction('createMidiAccessResource')({
+    attachStateChange: vi.fn(),
+    getInputPorts: () => inputs,
+    getOutputPorts: () => outputs,
+  });
+}
+
+function createEmptyAccess(): unknown {
+  return createAccess([], []);
+}
+
+function requiredFunction(name: string): (...args: unknown[]) => unknown {
+  const value: unknown = Reflect.get(midi, name);
+  expect(value, `${name} export`).toBeTypeOf('function');
+  if (typeof value !== 'function') throw new TypeError(`${name} is not exported`);
+  return value as (...args: unknown[]) => unknown;
+}

package/src/midiPermission.test.ts

@@ -0,0 +1,27 @@
+import { createEntity } from '@flighthq/entity/contract';
+import { describe, expect, it, vi } from 'vitest';
+
+import * as midi from './contract';
+
+describe('getMidiPermission', () => {
+  it('queries only the explicit MIDI permission owner and preserves shared query outcomes', async () => {
+    const getPermission = vi
+      .fn()
+      .mockResolvedValueOnce({ reason: 'ok', state: 'prompt' })
+      .mockResolvedValueOnce({ reason: 'unsupported' })
+      .mockRejectedValueOnce(new Error('provider fault'));
+    const host = { midi: { permission: createEntity({ getPermission }) } };
+    const getMidiPermission = requiredFunction('getMidiPermission');
+    await expect(getMidiPermission(host)).resolves.toEqual({ reason: 'ok', state: 'prompt' });
+    await expect(getMidiPermission(host)).resolves.toEqual({ reason: 'unsupported' });
+    await expect(getMidiPermission(host)).resolves.toEqual({ reason: 'operation-failed' });
+    expect(getPermission).toHaveBeenCalledTimes(3);
+  });
+});
+
+function requiredFunction(name: string): (...args: unknown[]) => unknown {
+  const value: unknown = Reflect.get(midi, name);
+  expect(value, `${name} export`).toBeTypeOf('function');
+  if (typeof value !== 'function') throw new TypeError(`${name} is not exported`);
+  return value as (...args: unknown[]) => unknown;
+}

package/src/midiPort.test.ts

@@ -0,0 +1,259 @@
+import { createEntity } from '@flighthq/entity/contract';
+import { EntityRuntimeKey } from '@flighthq/types/contract';
+import { describe, expect, it, vi } from 'vitest';
+
+import * as midi from './contract';
+
+describe('closeMidiPort', () => {
+  it('distinguishes a successful close, an already-closed port, disposal, and provider failure', async () => {
+    const connection = { value: 'open' };
+    const close = vi.fn(async () => {
+      connection.value = 'closed';
+    });
+    const port = createOutputPort({ close, connection });
+    const closeMidiPort = requiredFunction('closeMidiPort');
+    await expect(closeMidiPort(port)).resolves.toEqual({ reason: 'closed' });
+    await expect(closeMidiPort(port)).resolves.toEqual({ reason: 'already-closed' });
+    expect(close).toHaveBeenCalledOnce();
+    await requiredFunction('disposeMidiPort')(port);
+    await expect(closeMidiPort(port)).resolves.toEqual({ reason: 'disposed' });
+
+    const failed = createOutputPort({
+      close: vi.fn(async () => Promise.reject(new Error('close'))),
+      connection: { value: 'open' },
+    });
+    await expect(closeMidiPort(failed)).resolves.toEqual({ reason: 'operation-failed' });
+  });
+});
+
+describe('createMidiInputPortResource', () => {
+  it('creates a typed Entity with immutable diagnostic metadata only', () => {
+    const port = createInputPort();
+    expect(EntityRuntimeKey in port).toBe(true);
+    expect(port).toMatchObject({
+      id: 'shared-id',
+      manufacturer: 'Flight',
+      name: 'Input',
+      type: 'input',
+      version: '1',
+    });
+    expect(Object.keys(port).sort()).toEqual(['id', 'manufacturer', 'name', 'type', 'version']);
+  });
+});
+
+describe('createMidiOutputPortResource', () => {
+  it('creates a distinct output Entity even when a native id matches an input', () => {
+    const input = createInputPort();
+    const output = createOutputPort();
+    expect(EntityRuntimeKey in output).toBe(true);
+    expect(output).not.toBe(input);
+    expect(output).toMatchObject({ id: input.id, type: 'output' });
+  });
+});
+
+describe('disposeMidiPort', () => {
+  it('closes only a port opened through Flight, attempts failure again, and is terminal after success', async () => {
+    const disposeMidiPort = requiredFunction('disposeMidiPort');
+    const openMidiPort = requiredFunction('openMidiPort');
+    const ownedConnection = { value: 'closed' };
+    const ownedClose = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('first close failed'))
+      .mockImplementationOnce(async () => {
+        ownedConnection.value = 'closed';
+      });
+    const owned = createOutputPort({ close: ownedClose, connection: ownedConnection });
+    await expect(openMidiPort(owned)).resolves.toEqual({ reason: 'opened' });
+    await expect(disposeMidiPort(owned)).resolves.toEqual({
+      failures: [{ operation: 'close' }],
+      reason: 'operation-failed',
+    });
+    await expect(disposeMidiPort(owned)).resolves.toEqual({ reason: 'ok' });
+    await expect(disposeMidiPort(owned)).resolves.toEqual({ reason: 'already-disposed' });
+    expect(ownedClose).toHaveBeenCalledTimes(2);
+
+    const borrowedClose = vi.fn(async () => undefined);
+    const borrowed = createOutputPort({ close: borrowedClose, connection: { value: 'open' } });
+    await expect(openMidiPort(borrowed)).resolves.toEqual({ reason: 'already-open' });
+    await expect(disposeMidiPort(borrowed)).resolves.toEqual({ reason: 'ok' });
+    expect(borrowedClose).not.toHaveBeenCalled();
+  });
+
+  it('attempts every attached subscription and owned close, then retries only failed releases', async () => {
+    const stateRelease = vi
+      .fn()
+      .mockResolvedValueOnce({ reason: 'operation-failed' })
+      .mockResolvedValueOnce({ reason: 'ok' });
+    const messageRelease = vi
+      .fn()
+      .mockResolvedValueOnce({ reason: 'operation-failed' })
+      .mockResolvedValueOnce({ reason: 'ok' });
+    const connection = { value: 'closed' };
+    const close = vi.fn(async () => {
+      connection.value = 'closed';
+    });
+    const input = createInputPort({
+      attachMessage: async () => ({ attachment: createEntity({ release: messageRelease }), reason: 'ok' }),
+      attachStateChange: async () => ({ attachment: createEntity({ release: stateRelease }), reason: 'ok' }),
+      close,
+      connection,
+    });
+    const messageSubscription = requiredFunction('createMidiInputMessageSubscription')();
+    const stateSubscription = requiredFunction('createMidiPortStateSubscription')();
+    await requiredFunction('attachMidiInputMessageSubscription')(input, messageSubscription);
+    await requiredFunction('attachMidiPortStateSubscription')(input, stateSubscription);
+    await requiredFunction('openMidiPort')(input);
+
+    const disposeMidiPort = requiredFunction('disposeMidiPort');
+    await expect(disposeMidiPort(input)).resolves.toEqual({
+      failures: [{ operation: 'state-subscription-release' }, { operation: 'message-subscription-release' }],
+      reason: 'operation-failed',
+    });
+    expect(close).toHaveBeenCalledOnce();
+    await expect(disposeMidiPort(input)).resolves.toEqual({ reason: 'ok' });
+    expect(close).toHaveBeenCalledOnce();
+    expect(stateRelease).toHaveBeenCalledTimes(2);
+    expect(messageRelease).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('getMidiPortConnection', () => {
+  it('pulls current connection from the exact origin and reports disposed resources', async () => {
+    const first = createInputPort({ connection: { value: 'open' } });
+    const second = createInputPort({ connection: { value: 'closed' } });
+    const getMidiPortConnection = requiredFunction('getMidiPortConnection');
+    expect(getMidiPortConnection(first)).toEqual({ connection: 'open', reason: 'ok' });
+    expect(getMidiPortConnection(second)).toEqual({ connection: 'closed', reason: 'ok' });
+    await requiredFunction('disposeMidiPort')(second);
+    expect(getMidiPortConnection(second)).toEqual({ reason: 'disposed' });
+  });
+});
+
+describe('getMidiPortState', () => {
+  it('pulls dynamic state instead of mirroring it into public metadata', () => {
+    const state = { value: 'connected' };
+    const port = createInputPort({ state });
+    const getMidiPortState = requiredFunction('getMidiPortState');
+    expect(getMidiPortState(port)).toEqual({ reason: 'ok', state: 'connected' });
+    state.value = 'disconnected';
+    expect(getMidiPortState(port)).toEqual({ reason: 'ok', state: 'disconnected' });
+    expect(Reflect.has(port, 'state')).toBe(false);
+    expect(Reflect.has(port, 'connection')).toBe(false);
+  });
+});
+
+describe('openMidiPort', () => {
+  it('distinguishes open, already-open, disconnected, disposed, and provider failure', async () => {
+    const connection = { value: 'closed' };
+    const open = vi.fn(async () => {
+      connection.value = 'open';
+    });
+    const port = createInputPort({ connection, open });
+    const openMidiPort = requiredFunction('openMidiPort');
+    await expect(openMidiPort(port)).resolves.toEqual({ reason: 'opened' });
+    await expect(openMidiPort(port)).resolves.toEqual({ reason: 'already-open' });
+    expect(open).toHaveBeenCalledOnce();
+
+    const disconnected = createInputPort({ state: { value: 'disconnected' } });
+    await expect(openMidiPort(disconnected)).resolves.toEqual({ reason: 'disconnected' });
+    await requiredFunction('disposeMidiPort')(disconnected);
+    await expect(openMidiPort(disconnected)).resolves.toEqual({ reason: 'disposed' });
+
+    const failed = createInputPort({ open: vi.fn(async () => Promise.reject(new Error('open'))) });
+    await expect(openMidiPort(failed)).resolves.toEqual({ reason: 'operation-failed' });
+  });
+});
+
+describe('sendMidiMessage', () => {
+  it('validates one basic message before the provider and never admits system exclusive data', async () => {
+    const send = vi.fn();
+    const connection = { value: 'closed' };
+    const output = createOutputPort({ connection, send });
+    const sendMidiMessage = requiredFunction('sendMidiMessage');
+    expect(sendMidiMessage(output, new Uint8Array())).toEqual({ reason: 'invalid-message' });
+    expect(sendMidiMessage(output, new Uint8Array([0x40]))).toEqual({ reason: 'invalid-message' });
+    expect(sendMidiMessage(output, new Uint8Array([0x90, 0x40]))).toEqual({ reason: 'invalid-message' });
+    expect(sendMidiMessage(output, new Uint8Array([0x90, 0x90, 0x7f]))).toEqual({ reason: 'invalid-message' });
+    expect(sendMidiMessage(output, new Uint8Array([0xf0, 0x01, 0xf7]))).toEqual({
+      reason: 'system-exclusive-not-enabled',
+    });
+    expect(sendMidiMessage(output, new Uint8Array([0x90, 0x40, 0x7f]))).toEqual({ reason: 'not-open' });
+    expect(send).not.toHaveBeenCalled();
+
+    connection.value = 'open';
+    expect(sendMidiMessage(output, new Uint8Array([0x90, 0x40, 0x7f]), 12.5)).toEqual({ reason: 'sent' });
+    expect(send).toHaveBeenCalledWith([0x90, 0x40, 0x7f], 12.5);
+
+    const disconnected = createOutputPort({ connection: { value: 'open' }, state: { value: 'disconnected' } });
+    expect(sendMidiMessage(disconnected, new Uint8Array([0x80, 0x40, 0]))).toEqual({ reason: 'disconnected' });
+  });
+});
+
+interface MutableValue {
+  value: string;
+}
+
+interface PortOverrides {
+  attachMessage?: (listener: (data: Uint8Array, timestamp: number) => void) => Promise<unknown>;
+  attachStateChange?: (listener: () => void) => Promise<unknown>;
+  close?: () => Promise<void>;
+  connection?: MutableValue;
+  open?: () => Promise<void>;
+  send?: (data: readonly number[], timestamp?: number) => void;
+  state?: MutableValue;
+}
+
+function createInputPort(overrides: Readonly<PortOverrides> = {}): Record<string, unknown> {
+  const connection = overrides.connection ?? { value: 'closed' };
+  const state = overrides.state ?? { value: 'connected' };
+  return requiredFunction('createMidiInputPortResource')(
+    { id: 'shared-id', manufacturer: 'Flight', name: 'Input', version: '1' },
+    {
+      attachMessage: overrides.attachMessage ?? vi.fn(),
+      attachStateChange: overrides.attachStateChange ?? vi.fn(),
+      close:
+        overrides.close ??
+        (async () => {
+          connection.value = 'closed';
+        }),
+      getConnection: () => connection.value,
+      getState: () => state.value,
+      open:
+        overrides.open ??
+        (async () => {
+          connection.value = 'open';
+        }),
+    },
+  ) as Record<string, unknown>;
+}
+
+function createOutputPort(overrides: Readonly<PortOverrides> = {}): Record<string, unknown> {
+  const connection = overrides.connection ?? { value: 'closed' };
+  const state = overrides.state ?? { value: 'connected' };
+  return requiredFunction('createMidiOutputPortResource')(
+    { id: 'shared-id', manufacturer: 'Flight', name: 'Output', version: '1' },
+    {
+      attachStateChange: vi.fn(),
+      close:
+        overrides.close ??
+        (async () => {
+          connection.value = 'closed';
+        }),
+      getConnection: () => connection.value,
+      getState: () => state.value,
+      open:
+        overrides.open ??
+        (async () => {
+          connection.value = 'open';
+        }),
+      send: overrides.send ?? vi.fn(),
+    },
+  ) as Record<string, unknown>;
+}
+
+function requiredFunction(name: string): (...args: unknown[]) => unknown {
+  const value: unknown = Reflect.get(midi, name);
+  expect(value, `${name} export`).toBeTypeOf('function');
+  if (typeof value !== 'function') throw new TypeError(`${name} is not exported`);
+  return value as (...args: unknown[]) => unknown;
+}