sync package-lock

Bump typescript-eslint from 8.61.0 to 8.63.0

.eslintrc.js

@@ -1,12 +0,0 @@
-module.exports = {
-  env: {
-    node: true,
-    commonjs: true,
-    es2021: true,
-  },
-  extends: ['airbnb', 'prettier'],
-  parserOptions: {
-    ecmaVersion: 'latest',
-  },
-  ignorePatterns: ['**/node_modules', '**/dist'],
-};

.github/dependabot.yml

@@ -4,3 +4,18 @@ updates:
     directory: '/'
     schedule:
       interval: 'weekly'
+    ignore:
+      - dependency-name: '@types*'
+        update-types: ['version-update:semver-major', 'version-update:semver-minor']
+  - package-ecosystem: 'npm'
+    directory: 'apps/makeosc'
+    schedule:
+      interval: 'weekly'
+  - package-ecosystem: 'npm'
+    directory: 'apps/readosc'
+    schedule:
+      interval: 'weekly'
+  - package-ecosystem: 'npm'
+    directory: 'apps/sendosc'
+    schedule:
+      interval: 'weekly'

.github/workflows/check-osc-build.yml

@@ -3,10 +3,8 @@ on:
   pull_request:
     branches:
       - main
-    paths:
-      - 'packages/osc/**'
 jobs:
-  build-webui:
+  build:
     runs-on: ubuntu-latest
     steps:
       - name: Check out repository

.github/workflows/publish-makeosc.yml

@@ -1,24 +0,0 @@
-name: Publish makeosc to npmjs
-on:
-  push:
-    tags:
-      - 'makeosc/*'
-jobs:
-  publish:
-    permissions:
-      id-token: write
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4.0.3
-        with:
-          node-version-file: '.nvmrc'
-          registry-url: 'https://registry.npmjs.org'
-          cache: 'npm'
-          cache-dependency-path: './package-lock.json'
-      - name: Install Node.js dependencies
-        run: npm ci --workspace=makeosc
-      - name: Publish to NPM
-        run: npm publish --provenance --access=public --workspace=makeosc
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/publish-osc-npm.yml

@@ -22,5 +22,3 @@ jobs:
 
       - name: Publish to NPM
         run: npm publish --provenance --access=public --workspace @jwetzell/osc
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/publish-readosc.yml

@@ -1,24 +0,0 @@
-name: Publish readosc to npmjs
-on:
-  push:
-    tags:
-      - 'readosc/*'
-jobs:
-  publish:
-    permissions:
-      id-token: write
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4.0.3
-        with:
-          node-version-file: '.nvmrc'
-          registry-url: 'https://registry.npmjs.org'
-          cache: 'npm'
-          cache-dependency-path: './package-lock.json'
-      - name: Install Node.js dependencies
-        run: npm ci --workspace=readosc
-      - name: Publish to NPM
-        run: npm publish --provenance --access=public --workspace=readosc
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/publish-sendosc.yml

@@ -1,24 +0,0 @@
-name: Publish sendosc to npmjs
-on:
-  push:
-    tags:
-      - 'sendosc/*'
-jobs:
-  publish:
-    permissions:
-      id-token: write
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4.0.3
-        with:
-          node-version-file: '.nvmrc'
-          registry-url: 'https://registry.npmjs.org'
-          cache: 'npm'
-          cache-dependency-path: './package-lock.json'
-      - name: Install Node.js dependencies
-        run: npm ci --workspace=sendosc
-      - name: Publish to NPM
-        run: npm publish --provenance --access=public --workspace=sendosc
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.nvmrc

@@ -1 +1 @@
-v20.15.1
+v24.15.0

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Joel Wetzell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,5 +1,4 @@
 # osc-js
-Collection of OSC things written in JS/TS
+Typescript implementation of OSC things written in TS and distributed as both ESM and CJS modules
 
-- [osc encoding/decoding library](./packages/osc/)
-- [cli for sending osc messages](./apps/sendosc/)
+- [osc encoding/decoding library](./packages/osc/)

apps/makeosc/.gitignore

@@ -1 +0,0 @@
-dist

apps/makeosc/README.md

@@ -1,41 +0,0 @@
-![npm](https://img.shields.io/npm/v/makeosc)
-
-# makeosc
-
-Simple NodeJS script for generating OSC bytes output to stdout.
-
-## Usage
-
-```
-Usage: makeosc [options]
-
-simple util to make osc buffers
-
-Options:
-  -V, --version        output the version number
-  --address <address>  OSC address
-  --args <args...>     osc args (default: [])
-  --slip               slip encode message (default: false)
-  --types <types...>   osc arg types (choices: "s", "i", "f", "b", default: [])
-  -h, --help           display help for command
-```
-
-- using npx `npx makeosc@latest --address /hello`
-- install using `npm install -g makeosc@latest` and run `makeosc --address /hello`
-
-## Notes
-
-- `--types` option is a space seperate list of type characters that will determine what the corresponding argument type will be set to
-  - optional
-  - uses type codes from the OSC spec
-- `--args` option is a space-separated list of arguments. If a corresponding type is not found in the `--types` option it will default to string (`s`).
-  - blobs (`b`) are to be entered as hex string representing the buffer to be sent so the ASCII string `hello` would be `68656c6c6f`
-- the default protocol is UDP but can be changed to TCP using the `--protocol` flag
-
-## Examples
-
-- `makeosc --address /test --args 1.0`
-- `makeosc --address /this/is/sent/via/tcp`
-- `makeosc --address /test/with/types --args 1 2.0 three --types i f`
-  - note that `types` is not the same length as `args` so the remaining argument (`three`) will default to string
-- `makeosc --address /blob --args 68656c6c6f --types b`

apps/makeosc/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "makeosc",
-  "version": "0.1.0",
-  "description": "Simple NodeJS utility for generating osc buffers",
-  "main": "src/main.js",
-  "bin": {
-    "makeosc": "src/main.js"
-  },
-  "files": [
-    "src/"
-  ],
-  "author": {
-    "name": "Joel Wetzell",
-    "email": "me@jwetzell.com",
-    "url": "https://jwetzell.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jwetzell/osc-js.git"
-  },
-  "license": "MIT",
-  "dependencies": {
-    "@jwetzell/osc": "0.2.2",
-    "commander": "^11.0.0",
-    "slip": "^1.0.2"
-  }
-}

apps/makeosc/src/main.js

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-
-const { Option, program } = require('commander');
-const slip = require('slip');
-const { argToTypedArg } = require('./utils');
-const osc = require('@jwetzell/osc');
-const packageInfo = require('../package.json');
-
-program.name(packageInfo.name);
-program.version(packageInfo.version);
-program.description('simple util to make osc buffers');
-program.addOption(new Option('--address <address>', 'OSC address').makeOptionMandatory());
-program.addOption(new Option('--args <args...>', 'osc args').default([]));
-program.addOption(new Option('--slip', 'slip encode message').default(false));
-program.addOption(new Option('--types <types...>', 'osc arg types').choices(['s', 'i', 'f', 'b']).default([]));
-program.addOption(
-  new Option('-f --format <format>', 'output format').choices(['bytes', 'json', 'f', 'b']).default('bytes')
-);
-program.action((options) => {
-  const { address, args, types, format } = options;
-
-  const typedArgs = args?.map((rawArg, index) => {
-    const argType = types[index] || 's';
-
-    return {
-      type: argType,
-      value: argToTypedArg(rawArg, argType),
-    };
-  });
-
-  const oscMsg = {
-    address,
-    args: typedArgs,
-  };
-
-  if (format === 'json') {
-    process.stdout.write(JSON.stringify(oscMsg));
-  } else if (format === 'bytes') {
-    let oscMsgBuffer = osc.messageToBuffer(oscMsg);
-    if (options.slip) {
-      oscMsgBuffer = slip.encode(oscMsgBuffer);
-    }
-    process.stdout.write(oscMsgBuffer);
-  }
-});
-program.parse();
-
-process.stdout.on('error', (err) => {
-  if (err.code === 'EPIPE') {
-    process.exit(0);
-  }
-});

apps/makeosc/src/utils.js

@@ -1,31 +0,0 @@
-const oscTypeConverterMap = {
-  s: {
-    fromString: (string) => string,
-  },
-  f: {
-    fromString: (string) => Number.parseFloat(string),
-  },
-  i: {
-    fromString: (string) => Number.parseInt(string, 10),
-  },
-  b: {
-    fromString: (string) => Buffer.from(string, 'hex'),
-  },
-};
-
-function argToTypedArg(rawArg, type = 's') {
-  const typeConverter = oscTypeConverterMap[type];
-  if (typeConverter === undefined) {
-    throw new Error('osc type error: unknown type '.concat(type));
-  }
-
-  if (typeConverter.fromString === undefined) {
-    throw new Error('osc type error: no string converter for type '.concat(type));
-  }
-
-  return typeConverter.fromString(rawArg);
-}
-
-module.exports = {
-  argToTypedArg,
-};

apps/readosc/.gitignore

@@ -1 +0,0 @@
-dist

apps/readosc/README.md

@@ -1,20 +0,0 @@
-![npm](https://img.shields.io/npm/v/readosc)
-
-# readosc
-
-Simple NodeJS script for parsing OSC bytes from stdin.
-
-## Usage
-
-```
-Usage: readosc [options]
-
-simple util to read osc packets from stdin
-
-Options:
-  -V, --version  output the version number
-  -h, --help     display help for command
-```
-
-- using npx `npx readosc@latest`
-- install using `npm install -g readosc@latest` and run `readosc`

apps/readosc/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "readosc",
-  "version": "0.2.0",
-  "description": "Simple NodeJS utility for parsing osc buffers from stdin",
-  "main": "src/main.js",
-  "bin": {
-    "readosc": "src/main.js"
-  },
-  "files": [
-    "src/"
-  ],
-  "author": {
-    "name": "Joel Wetzell",
-    "email": "me@jwetzell.com",
-    "url": "https://jwetzell.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jwetzell/osc-js.git"
-  },
-  "license": "MIT",
-  "dependencies": {
-    "@jwetzell/osc": "1.0.0",
-    "commander": "^11.0.0"
-  }
-}

apps/readosc/src/main.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-
-const { program } = require('commander');
-const osc = require('@jwetzell/osc');
-const packageInfo = require('../package.json');
-
-program.name(packageInfo.name);
-program.version(packageInfo.version);
-program.description('simple util to read osc packets from stdin');
-program.action(() => {
-  process.stdin.on('data', (data) => {
-    try {
-      let remainingBytes = data;
-      while (remainingBytes.length > 0) {
-        try {
-          const [message, bytesAfterMessage] = osc.messageFromBuffer(remainingBytes);
-          remainingBytes = bytesAfterMessage;
-          console.log(JSON.stringify(message));
-        } catch (error) {
-          console.error({ error: error.toString() });
-        }
-      }
-    } catch (error) {
-      console.error({ error: error.toString() });
-    }
-  });
-});
-program.parse();

apps/sendosc/.gitignore

@@ -1 +0,0 @@
-dist

apps/sendosc/README.md

@@ -1,44 +0,0 @@
-![npm](https://img.shields.io/npm/v/sendosc)
-
-# sendosc
-
-Simple NodeJS script for sending OSC via TCP or UDP originally inspired by this [c++ utility](https://github.com/yoggy/sendosc) of the same name.
-
-## Usage
-
-```
-Usage: sendosc [options]
-
-simple util to sendosc
-
-Options:
-  -V, --version          output the version number
-  --protocol <protocol>  Network protocol (choices: "tcp", "udp", default: "udp")
-  --host <host>          the host to send osc to
-  --port <port>          the port to send osc to
-  --address <address>    OSC address
-  --args <args...>       osc args (default: [])
-  --slip                 slip encode message (default: false)
-  --types <types...>     osc arg types (choices: "s", "i", "f", "b", default: [])
-  -h, --help             display help for command
-```
-
-- using npx `npx sendosc@latest --host 127.0.0.1 --port 9999 --address /hello`
-- install using `npm install -g sendosc@latest` and run `sendosc --host 127.0.0.1 --port 9999 --address /hello`
-
-## Notes
-
-- `--types` option is a space seperate list of type characters that will determine what the corresponding argument type will be set to
-  - optional
-  - uses type codes from the OSC spec
-- `--args` option is a space-separated list of arguments. If a corresponding type is not found in the `--types` option it will default to string (`s`).
-  - blobs (`b`) are to be entered as hex string representing the buffer to be sent so the ASCII string `hello` would be `68656c6c6f`
-- the default protocol is UDP but can be changed to TCP using the `--protocol` flag
-
-## Examples
-
-- `sendosc --host 127.0.0.1 --port 8000 --address /test --args 1.0`
-- `sendosc --protocol tcp --host 127.0.0.1 --port 8000 --address /this/is/sent/via/tcp`
-- `sendosc --host 127.0.0.1 --port 8000 --address /test/with/types --args 1 2.0 three --types i f`
-  - note that `types` is not the same length as `args` so the remaining argument (`three`) will default to string
-- `sendosc --host 127.0.0.1 --port 8000 --address /blob --args 68656c6c6f --types b`

apps/sendosc/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "sendosc",
-  "version": "1.0.1",
-  "description": "Simple NodeJS utility for sending osc",
-  "main": "src/main.js",
-  "bin": {
-    "sendosc": "src/main.js"
-  },
-  "files": [
-    "src/"
-  ],
-  "author": {
-    "name": "Joel Wetzell",
-    "email": "me@jwetzell.com",
-    "url": "https://jwetzell.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jwetzell/osc-js.git"
-  },
-  "license": "MIT",
-  "dependencies": {
-    "@jwetzell/osc": "0.2.2",
-    "commander": "^11.0.0",
-    "slip": "^1.0.2"
-  }
-}

apps/sendosc/src/main.js

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-
-const { Option, program } = require('commander');
-const dgram = require('dgram');
-const net = require('net');
-const slip = require('slip');
-const osc = require('@jwetzell/osc');
-const { argToTypedArg } = require('./utils');
-const packageInfo = require('../package.json');
-
-program.name(packageInfo.name);
-program.version(packageInfo.version);
-program.description('simple util to sendosc');
-program.addOption(new Option('--protocol <protocol>', 'Network protocol').choices(['tcp', 'udp']).default('udp'));
-program.addOption(new Option('--host <host>', 'the host to send osc to').makeOptionMandatory());
-program.addOption(new Option('--port <port>', 'the port to send osc to').makeOptionMandatory());
-program.addOption(new Option('--address <address>', 'OSC address').makeOptionMandatory());
-program.addOption(new Option('--args <args...>', 'osc args').default([]));
-program.addOption(new Option('--slip', 'slip encode message').default(false));
-program.addOption(new Option('--types <types...>', 'osc arg types').choices(['s', 'i', 'f', 'b']).default([]));
-program.action((options) => {
-  const { host, port, address, args, types } = options;
-
-  const typedArgs = args?.map((rawArg, index) => {
-    const argType = types[index] || 's';
-
-    return {
-      type: argType,
-      value: argToTypedArg(rawArg, argType),
-    };
-  });
-
-  let oscMsgBuffer = osc.messageToBuffer({
-    address,
-    args: typedArgs,
-  });
-
-  if (options.slip) {
-    oscMsgBuffer = slip.encode(oscMsgBuffer);
-  }
-
-  if (options.protocol === 'tcp') {
-    const client = net.Socket();
-    client.on('error', (error) => {
-      console.error(error);
-    });
-    client.connect(port, host, () => {
-      client.write(oscMsgBuffer, () => {
-        client.destroy();
-      });
-    });
-  } else if (options.protocol === 'udp') {
-    const client = dgram.createSocket('udp4');
-    client.send(oscMsgBuffer, port, host, (error) => {
-      if (error) {
-        console.error(error);
-      }
-      client.close();
-    });
-  }
-});
-program.parse();

apps/sendosc/src/utils.js

@@ -1,31 +0,0 @@
-const oscTypeConverterMap = {
-  s: {
-    fromString: (string) => string,
-  },
-  f: {
-    fromString: (string) => Number.parseFloat(string),
-  },
-  i: {
-    fromString: (string) => Number.parseInt(string, 10),
-  },
-  b: {
-    fromString: (string) => Buffer.from(string, 'hex'),
-  },
-};
-
-function argToTypedArg(rawArg, type = 's') {
-  const typeConverter = oscTypeConverterMap[type];
-  if (typeConverter === undefined) {
-    throw new Error('osc type error: unknown type '.concat(type));
-  }
-
-  if (typeConverter.fromString === undefined) {
-    throw new Error('osc type error: no string converter for type '.concat(type));
-  }
-
-  return typeConverter.fromString(rawArg);
-}
-
-module.exports = {
-  argToTypedArg,
-};

eslint.config.mjs

@@ -0,0 +1,13 @@
+import globals from 'globals';
+import pluginJs from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import eslintPluginPrettier from 'eslint-plugin-prettier/recommended';
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  { ignores: ['apps/**/*', '**/*.test.js', 'eslint.config.mjs', '**/dist/**/*'] },
+  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintPluginPrettier,
+];

package.json

@@ -17,13 +17,15 @@
     "format:write": "prettier ./ --write"
   },
   "workspaces": [
-    "apps/*",
     "packages/*"
   ],
   "devDependencies": {
-    "prettier": "3.3.3",
-    "eslint": "^8.48.0",
-    "eslint-config-airbnb": "^19.0.4",
-    "eslint-config-prettier": "^9.0.0"
+    "@eslint/js": "10.0.1",
+    "eslint": "10.6.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.6",
+    "globals": "17.7.0",
+    "prettier": "3.9.5",
+    "typescript-eslint": "8.63.0"
   }
 }

packages/osc/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@jwetzell/osc",
-  "version": "1.2.0",
+  "version": "1.7.0",
   "description": "",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
   "scripts": {
     "prebuild": "rimraf dist",
-    "build": "tsc",
+    "build": "tsdown",
     "prepublishOnly": "npm run build",
     "pretest": "npm run build",
     "test": "node --test --experimental-test-coverage"
@@ -25,8 +31,11 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "22.7.4",
-    "rimraf": "6.0.1",
-    "typescript": "5.6.2"
-  }
+    "@types/node": "24.5.2",
+    "rimraf": "6.1.3",
+    "tsdown": "0.22.4",
+    "typescript": "7.0.2"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs"
 }

packages/osc/src/bundle.ts

@@ -1,9 +1,9 @@
-import { messageFromBuffer, messageToBuffer } from './message';
-import { OSCBundle } from './models';
-import { oscTypeConverterMap } from './osc-types';
+import { messageFromBuffer, messageToBuffer } from './message.js';
+import { type OSCBundle } from './models.js';
+import { oscTypeConverterMap } from './osc-types.js';
 
 export function bundleFromBuffer(bytes: Uint8Array): [OSCBundle | undefined, Uint8Array | undefined] {
-  if (bytes.length < 8) {
+  if (bytes.length < 20) {
     throw new Error('bundle has to be at least 20 bytes');
   }
 
@@ -11,8 +11,8 @@ export function bundleFromBuffer(bytes: Uint8Array): [OSCBundle | undefined, Uin
     throw new Error('bundle must start with #bundle');
   }
 
-  const [bundleHeader, bytesAfterHeader] = oscTypeConverterMap.s.fromBuffer(bytes);
-  let [timeTag, bytesAfterTimeTag] = oscTypeConverterMap.t.fromBuffer(bytesAfterHeader);
+  const [, bytesAfterHeader] = oscTypeConverterMap.s.fromBuffer(bytes);
+  const [timeTag, bytesAfterTimeTag] = oscTypeConverterMap.t.fromBuffer(bytesAfterHeader);
 
   if (!Array.isArray(timeTag)) {
     throw new Error('problem getting bundle time tag');
@@ -26,7 +26,7 @@ export function bundleFromBuffer(bytes: Uint8Array): [OSCBundle | undefined, Uin
   let remainingBytes = bytesAfterTimeTag;
 
   while (!endOfBundle) {
-    let [contentSize, bytesAfterContentSize] = oscTypeConverterMap.i.fromBuffer(remainingBytes);
+    const [contentSize, bytesAfterContentSize] = oscTypeConverterMap.i.fromBuffer(remainingBytes);
 
     if (typeof contentSize !== 'number') {
       throw new Error('problem decoding content size');
@@ -42,12 +42,12 @@ export function bundleFromBuffer(bytes: Uint8Array): [OSCBundle | undefined, Uin
 
     if (bundleContentBytes[0] === 35) {
       // # character indicating contents is a bundle
-      const [content, bytesAfterContent] = bundleFromBuffer(bundleContentBytes);
+      const [content] = bundleFromBuffer(bundleContentBytes);
       if (content) {
         bundleContents.push(content);
       }
     } else if (bundleContentBytes[0] === 47) {
-      const [content, bytesAfterContent] = messageFromBuffer(bundleContentBytes);
+      const [content] = messageFromBuffer(bundleContentBytes);
       if (content && content !== undefined) {
         bundleContents.push(content);
       }

packages/osc/src/index.ts

@@ -1,3 +1,19 @@
-export * from './models';
-export * from './message';
-export * from './bundle';
+import { bundleFromBuffer } from './bundle.js';
+import { messageFromBuffer } from './message.js';
+import type { OSCBundle, OSCMessage } from './models.js';
+
+export * from './models.js';
+export * from './message.js';
+export * from './bundle.js';
+
+export function fromBuffer(bytes: Uint8Array): [OSCBundle | OSCMessage | undefined, Uint8Array | undefined] {
+  if (bytes[0] === 47) {
+    // starts with '/'
+    return messageFromBuffer(bytes);
+  } else if (bytes[0] === 35) {
+    // starts with '#'
+    return bundleFromBuffer(bytes);
+  } else {
+    throw new Error('bytes do not look like an OSC message or bundle');
+  }
+}

packages/osc/src/message.ts

@@ -1,5 +1,5 @@
-import { OSCMessage, OSCArg, OSCType } from './models';
-import { oscTypeConverterMap } from './osc-types';
+import type { OSCMessage, OSCArg, OSCType } from './models.js';
+import { oscTypeConverterMap } from './osc-types.js';
 
 function argsToBuffer(args: OSCArg[]) {
   const argBuffers: Uint8Array[] = [];
@@ -28,17 +28,38 @@ function argsToBuffer(args: OSCArg[]) {
 }
 
 export function messageToBuffer(message: OSCMessage): Uint8Array {
+  if (!message.address.startsWith('/')) {
+    throw new Error('osc message must start with a /');
+  }
+
   const addressBuffer = oscTypeConverterMap.s.toBuffer(message.address);
   if (addressBuffer === undefined) {
     throw new Error('problem encoding address');
   }
 
-  const typeString = message.args.map((arg) => arg.type).join('');
-  const typesBuffer = oscTypeConverterMap.s.toBuffer(`,${typeString}`);
+  let typeString = ',';
+
+  const flatOSCArgs: OSCArg[] = [];
+
+  message.args.forEach((oscArg) => {
+    if (Array.isArray(oscArg)) {
+      typeString += '[';
+      oscArg.forEach((oscArg) => {
+        typeString += oscArg.type;
+        flatOSCArgs.push(oscArg);
+      });
+      typeString += ']';
+    } else {
+      typeString += oscArg.type;
+      flatOSCArgs.push(oscArg);
+    }
+  });
+
+  const typesBuffer = oscTypeConverterMap.s.toBuffer(typeString);
   if (typesBuffer === undefined) {
     throw new Error('problem encoding types');
   }
-  const argsBuffer = argsToBuffer(message.args);
+  const argsBuffer = argsToBuffer(flatOSCArgs);
   const buffer = new Uint8Array(addressBuffer.length + typesBuffer.length + argsBuffer.length);
   buffer.set(addressBuffer, 0);
   buffer.set(typesBuffer, addressBuffer.length);
@@ -51,19 +72,51 @@ export function messageFromBuffer(bytes: Uint8Array): [OSCMessage | undefined, U
     throw new Error('osc message must start with a /');
   }
 
-  const oscArgs: OSCArg[] = [];
+  const oscArgs: (OSCArg | OSCArg[])[] = [];
 
   const [address, bytesAfterAddress] = oscTypeConverterMap.s.fromBuffer(bytes);
   if (typeof address === 'string') {
-    let [typeString, bytesAfterType] = oscTypeConverterMap.s.fromBuffer(bytesAfterAddress);
+    if (bytesAfterAddress.length === 0) {
+      // NOTE(jwetzell): OSC 1.0 spec says that messages without a type string should be allowed
+      return [
+        {
+          address,
+          args: [],
+        },
+        bytesAfterAddress,
+      ];
+    }
+
+    const [typeString, bytesAfterType] = oscTypeConverterMap.s.fromBuffer(bytesAfterAddress);
     if (typeof typeString === 'string') {
       if (!typeString.startsWith(',')) {
         throw new Error('osc type string must start with a ,');
       }
       let argsBuffer = bytesAfterType;
+      let oscArrayArg: OSCArg[] = [];
+      let insideArgArray = false;
       for (let index = 1; index < typeString.length; index++) {
         const argType = typeString.charAt(index) as OSCType;
 
+        if (argType === '[') {
+          if (insideArgArray) {
+            throw new Error('osc arg array opened without closing previous arg array');
+          }
+          oscArrayArg = [];
+          insideArgArray = true;
+          continue;
+        }
+
+        if (argType === ']') {
+          if (!insideArgArray) {
+            throw new Error('osc arg array closed without opening arg array');
+          }
+          oscArgs.push(oscArrayArg);
+          oscArrayArg = [];
+          insideArgArray = false;
+          continue;
+        }
+
         const oscTypeConverter = oscTypeConverterMap[argType];
         if (oscTypeConverter === undefined) {
           throw new Error('unknown OSC type');
@@ -74,7 +127,11 @@ export function messageFromBuffer(bytes: Uint8Array): [OSCMessage | undefined, U
             type: argType,
             value: value,
           };
-          oscArgs.push(arg);
+          if (insideArgArray) {
+            oscArrayArg.push(arg);
+          } else {
+            oscArgs.push(arg);
+          }
         }
         argsBuffer = remainingBytes;
       }

packages/osc/src/models.ts

@@ -1,7 +1,7 @@
-export type OSCType = 's' | 'i' | 'f' | 'b' | 'T' | 'F' | 't' | 'r' | 'N';
+export type OSCType = 's' | 'i' | 'f' | 'b' | 'T' | 'F' | 't' | 'r' | 'N' | '[' | ']';
 export type OSCArg = {
   type: OSCType;
-  value: string | number | Uint8Array | boolean | OSCTimeTag | OSCColor | null;
+  value: string | number | Uint8Array | boolean | OSCTimeTag | OSCColor | bigint | null;
 };
 
 export type OSCTimeTag = [number, number];
@@ -20,12 +20,14 @@ export type OSCBundle = {
 
 export type OSCMessage = {
   address: string;
-  args: OSCArg[];
+  args: (OSCArg | OSCArg[])[];
 };
 
 export type OSCTypeConverter = {
-  toBuffer: (value: string | number | Uint8Array | boolean | OSCTimeTag | OSCColor | null) => Uint8Array | undefined;
+  toBuffer: (
+    value: string | number | Uint8Array | boolean | OSCTimeTag | OSCColor | null | bigint
+  ) => Uint8Array | undefined;
   fromBuffer: (
     buffer: Uint8Array
-  ) => [string | number | Uint8Array | boolean | OSCTimeTag | OSCColor | null | undefined, Uint8Array];
+  ) => [string | number | Uint8Array | boolean | OSCTimeTag | OSCColor | null | bigint | undefined, Uint8Array];
 };

packages/osc/src/osc-types.ts

@@ -1,4 +1,4 @@
-import { OSCTypeConverter, OSCTimeTag } from './models';
+import type { OSCTypeConverter, OSCTimeTag } from './models.js';
 
 export const oscTypeConverterMap: { [key: string]: OSCTypeConverter } = {
   s: {
@@ -160,7 +160,7 @@ export const oscTypeConverterMap: { [key: string]: OSCTypeConverter } = {
     },
     fromBuffer: (buffer) => {
       if (buffer.length < 8) {
-        throw new Error('osc time tag must be greater than 8 bytes');
+        throw new Error('osc time tag must be at least 8 bytes');
       }
       const [seconds, bytesAfterSeconds] = oscTypeConverterMap.i.fromBuffer(buffer);
       const [fractional, bytesAfterFractional] = oscTypeConverterMap.i.fromBuffer(bytesAfterSeconds);
@@ -173,7 +173,7 @@ export const oscTypeConverterMap: { [key: string]: OSCTypeConverter } = {
   },
   r: {
     toBuffer: (color) => {
-      if (color === undefined || color === null){
+      if (color === undefined || color === null) {
         throw new TypeError('osc type r called with undefined or null value');
       }
 
@@ -228,4 +228,61 @@ export const oscTypeConverterMap: { [key: string]: OSCTypeConverter } = {
       return [null, buffer];
     },
   },
+  I: {
+    toBuffer: () => {
+      return new Uint8Array();
+    },
+    fromBuffer: (buffer) => {
+      return [Number.MAX_SAFE_INTEGER, buffer];
+    },
+  },
+  h: {
+    toBuffer: (number) => {
+      const view = new DataView(new ArrayBuffer(8));
+
+      if (typeof number === 'number') {
+        view.setBigInt64(0, BigInt(number));
+      } else if (typeof number === 'bigint') {
+        view.setBigInt64(0, number);
+      } else {
+        throw new TypeError('osc type h toBuffer called with non number or bigint value');
+      }
+      return new Uint8Array(view.buffer);
+    },
+    fromBuffer: (buffer) => {
+      if (buffer.length < 8) {
+        throw new Error('osc int64 must be at least 8 bytes');
+      }
+
+      const view = new DataView(new ArrayBuffer(8));
+      buffer.subarray(0, 8).forEach((byte, index) => {
+        view.setUint8(index, byte);
+      });
+
+      return [view.getBigInt64(0), buffer.subarray(8)];
+    },
+  },
+  d: {
+    toBuffer: (number) => {
+      if (typeof number === 'number') {
+        const view = new DataView(new ArrayBuffer(8));
+        view.setFloat64(0, number);
+        return new Uint8Array(view.buffer);
+      }
+      throw new TypeError('osc type d toBuffer called with non number value');
+    },
+    fromBuffer: (buffer) => {
+      if (buffer.length < 8) {
+        throw new Error('not enough bytes to read a osc float');
+      }
+      const view = new DataView(new ArrayBuffer(8));
+
+      buffer.subarray(0, 8).forEach((byte, index) => {
+        view.setUint8(index, byte);
+      });
+
+      const value = view.getFloat64(0);
+      return [value, buffer.subarray(8)];
+    },
+  },
 };

packages/osc/tests/bundle-decode.test.js

@@ -1,8 +1,8 @@
-const { deepEqual, equal } = require('assert');
+const { deepEqual, equal, throws } = require('assert');
 const { describe, it } = require('node:test');
-const osc = require('../dist/index');
+const osc = require('@jwetzell/osc');
 
-const tests = [
+const goodTests = [
   {
     description: 'simple contents single message',
     bytes: new Uint8Array([
@@ -20,6 +20,34 @@ const tests = [
       contents: [{ address: '/oscillator/4/frequency', args: [{ type: 'f', value: 440 }] }],
     },
   },
+  {
+    description: 'simple contents single bundle',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x34]),
+      ...new Uint8Array([
+        ...new TextEncoder().encode('#bundle'),
+        ...new Uint8Array([0x00]),
+        ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+        ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+        ...new Uint8Array([
+          0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71,
+          0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00,
+        ]),
+      ]),
+    ]),
+    expected: {
+      timeTag: [32, 0],
+      contents: [
+        {
+          timeTag: [32, 0],
+          contents: [{ address: '/oscillator/4/frequency', args: [{ type: 'f', value: 440 }] }],
+        },
+      ],
+    },
+  },
   {
     description: 'resolume bundle example',
     bytes: new Uint8Array([
@@ -88,8 +116,71 @@ const tests = [
   },
 ];
 
-describe('OSC Bundle Decoding', () => {
-  tests.forEach((bundleTest) => {
+const badTests = [
+  {
+    description: 'bad bundle header',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+      ...new Uint8Array([
+        0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71,
+        0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00,
+      ]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle must start with #bundle',
+    },
+  },
+  {
+    description: 'incomplete bundle',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle has to be at least 20 bytes',
+    },
+  },
+  {
+    description: 'bundle not enough bytes',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+      ...new Uint8Array([0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle does not contain enough data',
+    },
+  },
+  {
+    description: 'bad bundle contents',
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+      ...new Uint8Array([
+        0x2a, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71,
+        0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00,
+      ]),
+    ]),
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'bundle contents does not look like a OSC message or bundle',
+    },
+  },
+];
+
+describe('OSC Bundle Decoding Pass', () => {
+  goodTests.forEach((bundleTest) => {
     it(bundleTest.description, () => {
       const [encoded, remainingBytes] = osc.bundleFromBuffer(bundleTest.bytes);
       equal(remainingBytes.length, 0);
@@ -97,3 +188,13 @@ describe('OSC Bundle Decoding', () => {
     });
   });
 });
+
+describe('OSC Bundle Decoding Throws', () => {
+  badTests.forEach((bundleTest) => {
+    it(bundleTest.description, () => {
+      throws(() => {
+        osc.bundleFromBuffer(bundleTest.bytes);
+      }, bundleTest.throwsMessage);
+    });
+  });
+});

packages/osc/tests/bundle-encode.test.js

@@ -1,6 +1,6 @@
 const { deepEqual } = require('assert');
 const { describe, it } = require('node:test');
-const osc = require('../dist/index');
+const osc = require('@jwetzell/osc');
 
 const tests = [
   {

packages/osc/tests/decode.test.js

@@ -0,0 +1,41 @@
+const { deepEqual, equal } = require('assert');
+const { describe, it } = require('node:test');
+const osc = require('@jwetzell/osc');
+
+const tests = [
+  {
+    description: 'simple bundle',
+    expected: {
+      timeTag: [32, 0],
+      contents: [{ address: '/oscillator/4/frequency', args: [{ type: 'f', value: 440 }] }],
+    },
+    bytes: new Uint8Array([
+      ...new TextEncoder().encode('#bundle'),
+      ...new Uint8Array([0x00]),
+      ...new Uint8Array([0, 0, 0, 32, 0, 0, 0, 0]),
+      ...new Uint8Array([0x00, 0x00, 0x00, 0x20]),
+      ...new Uint8Array([
+        0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71,
+        0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00,
+      ]),
+    ]),
+  },
+  {
+    description: 'osc 1.0 spec example 1',
+    bytes: new Uint8Array([
+      47, 111, 115, 99, 105, 108, 108, 97, 116, 111, 114, 47, 52, 47, 102, 114, 101, 113, 117, 101, 110, 99, 121, 0, 44,
+      102, 0, 0, 67, 220, 0, 0,
+    ]),
+    expected: { address: '/oscillator/4/frequency', args: [{ type: 'f', value: 440 }] },
+  },
+];
+
+describe('OSC Bytes Decoding', () => {
+  tests.forEach((bytesTest) => {
+    it(bytesTest.description, () => {
+      const [decoded, remainingBytes] = osc.fromBuffer(bytesTest.bytes);
+      deepEqual(decoded, bytesTest.expected);
+      equal(remainingBytes.length, 0);
+    });
+  });
+});

packages/osc/tests/message-decode.test.js

@@ -1,8 +1,8 @@
 const { deepEqual, throws, equal } = require('assert');
 const { describe, it } = require('node:test');
-const osc = require('../dist/index');
+const osc = require('@jwetzell/osc');
 
-const tests = [
+const goodTests = [
   {
     description: 'simple address no args',
     bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 0, 0, 0]),
@@ -48,6 +48,47 @@ const tests = [
     bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 78, 0, 0]),
     expected: { address: '/hello', args: [{ type: 'N', value: null }] },
   },
+  {
+    description: 'simple address Inifinitum arg',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 73, 0, 0]),
+    expected: { address: '/hello', args: [{ type: 'I', value: Number.MAX_SAFE_INTEGER }] },
+  },
+  {
+    description: 'simple address int64 arg',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 104, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255]),
+    expected: { address: '/hello', args: [{ type: 'h', value: 281474976710655n }] },
+  },
+  {
+    description: 'simple address float64 arg',
+    bytes: new Uint8Array([
+      47, 104, 101, 108, 108, 111, 0, 0, 44, 100, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6,
+    ]),
+    expected: { address: '/hello', args: [{ type: 'd', value: 12.7654763 }] },
+  },
+  {
+    description: 'simple address array arg',
+    bytes: new Uint8Array([
+      47, 104, 101, 108, 108, 111, 0, 0, 44, 91, 100, 105, 93, 0, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6,
+      0, 0, 3, 232,
+    ]),
+    expected: {
+      address: '/hello',
+      args: [
+        [
+          { type: 'd', value: 12.7654763 },
+          { type: 'i', value: 1000 },
+        ],
+      ],
+    },
+  },
+  {
+    description: 'simple address no type string',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0]),
+    expected: {
+      address: '/hello',
+      args: [],
+    },
+  },
   {
     description: 'osc 1.0 spec example 1',
     bytes: new Uint8Array([
@@ -76,83 +117,75 @@ const tests = [
   },
 ];
 
-describe('OSC Message Decoding', () => {
-  tests.forEach((messageTest) => {
+const badTests = [
+  {
+    description: 'bad address',
+    bytes: new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /must start with/ },
+  },
+
+  {
+    description: 'bad type string',
+    bytes: new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x42, 0x0a, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /type string must start with/ },
+  },
+  {
+    description: 'unknown type',
+    bytes: new Uint8Array([
+      0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x7a, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00,
+    ]),
+    throwsMessage: { name: /^Error$/, message: /unknown/ },
+  },
+  {
+    description: 'float arg missing bytes',
+    bytes: new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'int arg missing bytes',
+    bytes: new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'blob bytes too small',
+    bytes: new Uint8Array([
+      0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x62, 0x6c, 0x6f,
+    ]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'float64 missing bytes',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 100, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9]),
+    throwsMessage: { name: /^Error$/, message: /not enough bytes/ },
+  },
+  {
+    description: 'int64 missing bytes',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 104, 0, 0, 0, 0, 255, 255, 255, 255, 255]),
+    throwsMessage: { name: /^Error$/, message: /must be at least/ },
+  },
+  {
+    description: 'color missing bytes',
+    bytes: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 114, 0, 0, 20, 21, 22]),
+    throwsMessage: { name: /^Error$/, message: /must be at least/ },
+  },
+];
+
+describe('OSC Message Decoding Pass', () => {
+  goodTests.forEach((messageTest) => {
     it(messageTest.description, () => {
       const [decoded, remainingBytes] = osc.messageFromBuffer(messageTest.bytes);
       equal(remainingBytes.length, 0);
       deepEqual(decoded, messageTest.expected);
     });
   });
+});
 
-  it('bad address', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00])
-        );
-      },
-      { name: /^Error$/, message: /must start with/ }
-    );
-  });
-
-  it('bad type string', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x42, 0x0a, 0x00])
-        );
-      },
-      { name: /^Error$/, message: /type string must start with/ }
-    );
-  });
-
-  it('unknown type', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([
-            0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x7a, 0x00, 0x00, 0x42, 0x0a, 0x00, 0x00,
-          ])
-        );
-      },
-      { name: /^Error$/, message: /unknown/ }
-    );
-  });
-
-  it('float arg missing bytes', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x42, 0x0a, 0x00])
-        );
-      },
-      { name: /^Error$/, message: /not enough bytes/ }
-    );
-  });
-
-  it('int arg missing bytes', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00])
-        );
-      },
-      { name: /^Error$/, message: /not enough bytes/ }
-    );
-  });
-
-  it('blob bytes too small', () => {
-    throws(
-      () => {
-        osc.messageFromBuffer(
-          new Uint8Array([
-            0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x62, 0x6c,
-            0x6f,
-          ])
-        );
-      },
-      { name: /^Error$/, message: /not enough bytes/ }
-    );
+describe('OSC Message Decoding Throws', () => {
+  badTests.forEach((messageTest) => {
+    it(messageTest.description, () => {
+      throws(() => {
+        osc.messageFromBuffer(messageTest.bytes);
+      }, messageTest.throwsMessage);
+    });
   });
 });

packages/osc/tests/message-encode.test.js

@@ -1,8 +1,8 @@
 const { deepEqual, throws } = require('assert');
 const { describe, it } = require('node:test');
-const osc = require('../dist/index');
+const osc = require('@jwetzell/osc');
 
-const tests = [
+const goodTests = [
   {
     description: 'simple address no args',
     message: { address: '/hello', args: [] },
@@ -48,6 +48,34 @@ const tests = [
     message: { address: '/hello', args: [{ type: 'N', value: null }] },
     expected: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 78, 0, 0]),
   },
+  {
+    description: 'simple address int64 arg',
+    message: { address: '/hello', args: [{ type: 'h', value: 281474976710655n }] },
+    expected: new Uint8Array([47, 104, 101, 108, 108, 111, 0, 0, 44, 104, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255]),
+  },
+  {
+    description: 'simple address float64 arg',
+    message: { address: '/hello', args: [{ type: 'd', value: 12.7654763 }] },
+    expected: new Uint8Array([
+      47, 104, 101, 108, 108, 111, 0, 0, 44, 100, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6,
+    ]),
+  },
+  {
+    description: 'simple address array arg',
+    message: {
+      address: '/hello',
+      args: [
+        [
+          { type: 'd', value: 12.7654763 },
+          { type: 'i', value: 1000 },
+        ],
+      ],
+    },
+    expected: new Uint8Array([
+      47, 104, 101, 108, 108, 111, 0, 0, 44, 91, 100, 105, 93, 0, 0, 0, 0x40, 0x29, 0x87, 0xec, 0x82, 0x74, 0xb9, 0xe6,
+      0, 0, 3, 232,
+    ]),
+  },
   {
     description: 'osc 1.0 spec example 1',
     message: { address: '/oscillator/4/frequency', args: [{ type: 'f', value: 440 }] },
@@ -76,55 +104,58 @@ const tests = [
   },
 ];
 
-describe('OSC Message Encoding', () => {
-  tests.forEach((messageTest) => {
+const badTests = [
+  {
+    description: 'bad string arg',
+    message: { address: '/address', args: [{ type: 's', value: 123 }] },
+    throwsMessage: { name: /^TypeError$/, message: /non string/ },
+  },
+
+  {
+    description: 'bad integer arg',
+    message: { address: '/address', args: [{ type: 'i', value: 'hi' }] },
+    throwsMessage: { name: /^TypeError$/, message: /non number/ },
+  },
+  {
+    description: 'bad float arg',
+    message: { address: '/address', args: [{ type: 'f', value: 'hi' }] },
+    throwsMessage: { name: /^TypeError$/, message: /non number/ },
+  },
+  {
+    description: 'bad blob arg',
+    message: { address: '/address', args: [{ type: 'b', value: 123 }] },
+    throwsMessage: { name: /^TypeError$/, message: /non Uint8Array/ },
+  },
+  {
+    description: 'unknown arg type',
+    message: { address: '/address', args: [{ type: 'z', value: 123 }] },
+    throwsMessage: { name: /^TypeError$/, message: /unknown type z/ },
+  },
+  {
+    description: 'address that does not start with / should throw',
+    message: { address: 'address', args: [] },
+    throwsMessage: {
+      name: /^Error$/,
+      message: 'osc message must start with a /',
+    },
+  },
+];
+
+describe('OSC Message Encoding Pass', () => {
+  goodTests.forEach((messageTest) => {
     it(messageTest.description, () => {
       const encoded = osc.messageToBuffer(messageTest.message);
       deepEqual(encoded, messageTest.expected);
     });
   });
-  it('bad string arg', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 's', value: 123 }] });
-      },
-      { name: /^TypeError$/ }
-    );
-  });
+});
 
-  it('bad integer arg', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'i', value: 'hi' }] });
-      },
-      { name: /^TypeError$/ }
-    );
-  });
-
-  it('bad float arg', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'f', value: 'hi' }] });
-      },
-      { name: /^TypeError$/ }
-    );
-  });
-
-  it('bad blob arg', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'b', value: 123 }] });
-      },
-      { name: /^TypeError$/ }
-    );
-  });
-
-  it('unknown arg type', () => {
-    throws(
-      () => {
-        osc.messageToBuffer({ address: '/address', args: [{ type: 'z', value: 123 }] });
-      },
-      { name: /^TypeError$/ }
-    );
+describe('OSC Message Encoding Throws', () => {
+  badTests.forEach((messageTest) => {
+    it(messageTest.description, () => {
+      throws(() => {
+        osc.messageToBuffer(messageTest.message);
+      }, messageTest.throwsMessage);
+    });
   });
 });

packages/osc/tsconfig.json

@@ -1,12 +1,20 @@
 {
   "compilerOptions": {
-    "esModuleInterop": true,
-    "module": "commonjs",
-    "target": "ES2020",
-    "declaration": true,
-    "rootDir": "./src",
+    "target": "esnext",
+    "lib": ["es2023"],
+    "moduleDetection": "force",
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "types": ["node"],
     "strict": true,
-    "outDir": "dist"
+    "noUnusedLocals": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
   },
-  "exclude": ["node_modules", "dist", "examples"]
+  "include": ["src"]
 }

packages/osc/tsdown.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: 'src/index.ts',
+  exports: true,
+  format: {
+    esm: {},
+    cjs: {},
+  },
+});