@tabnas/proto 0.1.0

package/dist/detect-version.js

@@ -0,0 +1,47 @@
+"use strict";
+/* Copyright (c) 2026 Richard Rodger and other contributors, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declaredVersion = declaredVersion;
+exports.resolveVersion = resolveVersion;
+exports.isEdition = isEdition;
+exports.editionEnum = editionEnum;
+const SYNTAX_VERSIONS = new Set(['proto2', 'proto3']);
+const EDITION_VERSIONS = new Set(['2023', '2024']);
+// Pull the declared version out of a `syntaxOrEdition` CST node, or null
+// if the file has no leading `syntax`/`edition` declaration. The node's
+// `src` is whitespace-stripped, e.g. `syntax="proto3";` or `edition="2023";`.
+function declaredVersion(syntaxNode) {
+    if (!syntaxNode || 'string' !== typeof syntaxNode.src)
+        return null;
+    const m = syntaxNode.src.match(/^(syntax|edition)=["']([^"']+)["']/);
+    if (!m)
+        return null;
+    const value = m[2];
+    if (SYNTAX_VERSIONS.has(value) || EDITION_VERSIONS.has(value)) {
+        return value;
+    }
+    throw new Error(`proto: unknown ${m[1]} version "${value}"`);
+}
+// Reconcile the version declared in the source with the version supplied
+// via the plugin option. With `reconcile` true (the default) a mismatch is
+// an error; otherwise the declaration wins when present. Falls back to
+// proto2 (protoc's default for a file with no declaration and no option).
+function resolveVersion(declared, option, reconcile) {
+    if (null != declared && null != option && declared !== option) {
+        if (reconcile) {
+            throw new Error(`proto: version mismatch — option "${option}" but the file ` +
+                `declares "${declared}". Set reconcile:false to let the file win.`);
+        }
+        return declared;
+    }
+    return declared ?? option ?? 'proto2';
+}
+function isEdition(v) {
+    return EDITION_VERSIONS.has(v);
+}
+// FileDescriptorProto records syntax files via `syntax` and edition files
+// via `edition` (as `EDITION_2023` / `EDITION_2024`).
+function editionEnum(v) {
+    return 'EDITION_' + v;
+}
+//# sourceMappingURL=detect-version.js.map

package/dist/detect-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-version.js","sourceRoot":"","sources":["../src/detect-version.ts"],"names":[],"mappings":";AAAA,2EAA2E;;AAY3E,0CASC;AAMD,wCAeC;AAED,8BAEC;AAID,kCAEC;AA9CD,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAA;AACrD,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAElD,yEAAyE;AACzE,wEAAwE;AACxE,8EAA8E;AAC9E,SAAgB,eAAe,CAAC,UAAe;IAC7C,IAAI,CAAC,UAAU,IAAI,QAAQ,KAAK,OAAO,UAAU,CAAC,GAAG;QAAE,OAAO,IAAI,CAAA;IAClE,MAAM,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAA;IACpE,IAAI,CAAC,CAAC;QAAE,OAAO,IAAI,CAAA;IACnB,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;IAClB,IAAI,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9D,OAAO,KAAqB,CAAA;IAC9B,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,aAAa,KAAK,GAAG,CAAC,CAAA;AAC9D,CAAC;AAED,yEAAyE;AACzE,2EAA2E;AAC3E,uEAAuE;AACvE,0EAA0E;AAC1E,SAAgB,cAAc,CAC5B,QAA6B,EAC7B,MAA2B,EAC3B,SAAkB;IAElB,IAAI,IAAI,IAAI,QAAQ,IAAI,IAAI,IAAI,MAAM,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;QAC9D,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CACb,qCAAqC,MAAM,iBAAiB;gBAC5D,aAAa,QAAQ,6CAA6C,CACnE,CAAA;QACH,CAAC;QACD,OAAO,QAAQ,CAAA;IACjB,CAAC;IACD,OAAO,QAAQ,IAAI,MAAM,IAAI,QAAQ,CAAA;AACvC,CAAC;AAED,SAAgB,SAAS,CAAC,CAAe;IACvC,OAAO,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAChC,CAAC;AAED,0EAA0E;AAC1E,sDAAsD;AACtD,SAAgB,WAAW,CAAC,CAAe;IACzC,OAAO,UAAU,GAAG,CAAC,CAAA;AACvB,CAAC"}

package/dist/grammar.d.ts

@@ -0,0 +1 @@
+export declare const grammarText = "\n; ===== common.abnf =====\n; @tabnas/proto \u2014 Protocol Buffers .proto IDL, common (union base).\n; Structure only; lexical atoms are the engine's whole-word tokens:\n;   TX = identifier   NR = number   ST = string   VL = true/false/null\n; Whitespace and // and /* */ comments are ignored by the lexer.\n; The grammar is a permissive superset of proto2 / proto3 / editions;\n; version-specific legality is enforced in the descriptor walk.\n\nproto          = [ syntaxOrEdition ] *topLevelDef\n\nsyntaxOrEdition = \"syntax\" \"=\" strLit \";\"\n\ntopLevelDef    = importStmt / packageStmt / optionStmt / message / enumDef\n               / service / extendStmt / emptyStmt\n\nimportStmt     = \"import\" [ \"weak\" / \"public\" ] strLit \";\"\npackageStmt    = \"package\" fullIdent \";\"\n\noptionStmt     = \"option\" optionName \"=\" constant \";\"\noptionName     = optionNamePart *( \".\" optionNamePart )\noptionNamePart = ident / \"(\" [ \".\" ] fullIdent \")\"\n\nmessage        = \"message\" ident messageBody\nmessageBody    = \"{\" *messageElement \"}\"\nmessageElement = field / enumDef / message / optionStmt / oneof / mapField\n               / extendStmt / extensions / reserved / emptyStmt\n\nfield          = [ label ] fieldType ident \"=\" fieldNumber [ fieldOptions ] \";\"\nlabel          = \"required\" / \"optional\" / \"repeated\"\nfieldType      = messageType\nfieldNumber    = NR\nfieldOptions   = \"[\" fieldOption *( \",\" fieldOption ) \"]\"\nfieldOption    = optionName \"=\" constant\n\noneof          = \"oneof\" ident \"{\" *oneofElement \"}\"\noneofElement   = optionStmt / oneofField / emptyStmt\noneofField     = fieldType ident \"=\" fieldNumber [ fieldOptions ] \";\"\n\nmapField       = \"map\" \"<\" fieldType \",\" fieldType \">\" ident \"=\" fieldNumber\n                 [ fieldOptions ] \";\"\n\nenumDef        = \"enum\" ident \"{\" *enumElement \"}\"\nenumElement    = optionStmt / enumField / reserved / emptyStmt\nenumField      = ident \"=\" [ \"-\" ] fieldNumber [ fieldOptions ] \";\"\n\nservice        = \"service\" ident \"{\" *serviceElement \"}\"\nserviceElement = optionStmt / rpc / emptyStmt\nrpc            = \"rpc\" ident \"(\" [ \"stream\" ] messageType \")\"\n                 \"returns\" \"(\" [ \"stream\" ] messageType \")\"\n                 ( \";\" / \"{\" *( optionStmt / emptyStmt ) \"}\" )\n\nextendStmt     = \"extend\" messageType \"{\" *( field / emptyStmt ) \"}\"\nextensions     = \"extensions\" ranges [ fieldOptions ] \";\"\nreserved       = \"reserved\" ( ranges / fieldNames ) \";\"\nranges         = range *( \",\" range )\nrange          = NR [ \"to\" ( NR / \"max\" ) ]\nfieldNames     = strLit *( \",\" strLit )\n\nconstant       = boolLit / fullIdent / signedNumber / strLit / messageValue\nsignedNumber   = [ \"-\" / \"+\" ] NR\nboolLit        = VL\nmessageValue   = \"{\" *messageValueEntry \"}\"\nmessageValueEntry = ident [ \":\" ] constant [ \",\" / \";\" ]\n\nmessageType    = [ \".\" ] fullIdent\nfullIdent      = ident *( \".\" ident )\nident          = TX\nstrLit         = ST\nemptyStmt      = \";\"\n\n; ===== proto2.abnf =====\n; proto2 deltas: groups are proto2-only (deprecated). Labels (required/\n; optional/repeated), extend, and extensions live in common (the permissive\n; union); the descriptor walk enforces what each version actually allows.\nmessageElement =/ groupField\ngroupField     = [ label ] \"group\" ident \"=\" fieldNumber messageBody\n\n; ===== proto3.abnf =====\n; proto3 deltas: none. proto3's surface syntax is the common base\n; (implicit label via the optional [ label ], plus the \"optional\" keyword).\n; Version legality (no required, no group) is enforced in the walk.\n\n; ===== edition-2023.abnf =====\n; edition 2023 deltas: the file may open with an `edition = \"2023\";`\n; declaration instead of `syntax = ...`.\nsyntaxOrEdition =/ editionDecl\neditionDecl     = \"edition\" \"=\" strLit \";\"\n\n; ===== edition-2024.abnf =====\n; edition 2024 deltas: `import option \"...\";` and symbol visibility\n; (export / local) on message and enum declarations.\nimportStmt      =/ \"import\" \"option\" strLit \";\"\ntopLevelDef     =/ symbolVisibility message / symbolVisibility enumDef\nmessageElement  =/ symbolVisibility message / symbolVisibility enumDef\nsymbolVisibility = \"export\" / \"local\"\n";

package/dist/grammar.js

@@ -0,0 +1,104 @@
+"use strict";
+/* Copyright (c) 2026 Richard Rodger and other contributors, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grammarText = void 0;
+// GENERATED by embed-grammar.js from proto-grammar/*.abnf — do not edit.
+// Run `npm run embed` after changing any .abnf file.
+exports.grammarText = `
+; ===== common.abnf =====
+; @tabnas/proto — Protocol Buffers .proto IDL, common (union base).
+; Structure only; lexical atoms are the engine's whole-word tokens:
+;   TX = identifier   NR = number   ST = string   VL = true/false/null
+; Whitespace and // and /* */ comments are ignored by the lexer.
+; The grammar is a permissive superset of proto2 / proto3 / editions;
+; version-specific legality is enforced in the descriptor walk.
+
+proto          = [ syntaxOrEdition ] *topLevelDef
+
+syntaxOrEdition = "syntax" "=" strLit ";"
+
+topLevelDef    = importStmt / packageStmt / optionStmt / message / enumDef
+               / service / extendStmt / emptyStmt
+
+importStmt     = "import" [ "weak" / "public" ] strLit ";"
+packageStmt    = "package" fullIdent ";"
+
+optionStmt     = "option" optionName "=" constant ";"
+optionName     = optionNamePart *( "." optionNamePart )
+optionNamePart = ident / "(" [ "." ] fullIdent ")"
+
+message        = "message" ident messageBody
+messageBody    = "{" *messageElement "}"
+messageElement = field / enumDef / message / optionStmt / oneof / mapField
+               / extendStmt / extensions / reserved / emptyStmt
+
+field          = [ label ] fieldType ident "=" fieldNumber [ fieldOptions ] ";"
+label          = "required" / "optional" / "repeated"
+fieldType      = messageType
+fieldNumber    = NR
+fieldOptions   = "[" fieldOption *( "," fieldOption ) "]"
+fieldOption    = optionName "=" constant
+
+oneof          = "oneof" ident "{" *oneofElement "}"
+oneofElement   = optionStmt / oneofField / emptyStmt
+oneofField     = fieldType ident "=" fieldNumber [ fieldOptions ] ";"
+
+mapField       = "map" "<" fieldType "," fieldType ">" ident "=" fieldNumber
+                 [ fieldOptions ] ";"
+
+enumDef        = "enum" ident "{" *enumElement "}"
+enumElement    = optionStmt / enumField / reserved / emptyStmt
+enumField      = ident "=" [ "-" ] fieldNumber [ fieldOptions ] ";"
+
+service        = "service" ident "{" *serviceElement "}"
+serviceElement = optionStmt / rpc / emptyStmt
+rpc            = "rpc" ident "(" [ "stream" ] messageType ")"
+                 "returns" "(" [ "stream" ] messageType ")"
+                 ( ";" / "{" *( optionStmt / emptyStmt ) "}" )
+
+extendStmt     = "extend" messageType "{" *( field / emptyStmt ) "}"
+extensions     = "extensions" ranges [ fieldOptions ] ";"
+reserved       = "reserved" ( ranges / fieldNames ) ";"
+ranges         = range *( "," range )
+range          = NR [ "to" ( NR / "max" ) ]
+fieldNames     = strLit *( "," strLit )
+
+constant       = boolLit / fullIdent / signedNumber / strLit / messageValue
+signedNumber   = [ "-" / "+" ] NR
+boolLit        = VL
+messageValue   = "{" *messageValueEntry "}"
+messageValueEntry = ident [ ":" ] constant [ "," / ";" ]
+
+messageType    = [ "." ] fullIdent
+fullIdent      = ident *( "." ident )
+ident          = TX
+strLit         = ST
+emptyStmt      = ";"
+
+; ===== proto2.abnf =====
+; proto2 deltas: groups are proto2-only (deprecated). Labels (required/
+; optional/repeated), extend, and extensions live in common (the permissive
+; union); the descriptor walk enforces what each version actually allows.
+messageElement =/ groupField
+groupField     = [ label ] "group" ident "=" fieldNumber messageBody
+
+; ===== proto3.abnf =====
+; proto3 deltas: none. proto3's surface syntax is the common base
+; (implicit label via the optional [ label ], plus the "optional" keyword).
+; Version legality (no required, no group) is enforced in the walk.
+
+; ===== edition-2023.abnf =====
+; edition 2023 deltas: the file may open with an \`edition = "2023";\`
+; declaration instead of \`syntax = ...\`.
+syntaxOrEdition =/ editionDecl
+editionDecl     = "edition" "=" strLit ";"
+
+; ===== edition-2024.abnf =====
+; edition 2024 deltas: \`import option "...";\` and symbol visibility
+; (export / local) on message and enum declarations.
+importStmt      =/ "import" "option" strLit ";"
+topLevelDef     =/ symbolVisibility message / symbolVisibility enumDef
+messageElement  =/ symbolVisibility message / symbolVisibility enumDef
+symbolVisibility = "export" / "local"
+`;
+//# sourceMappingURL=grammar.js.map

package/dist/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../src/grammar.ts"],"names":[],"mappings":";AAAA,2EAA2E;;;AAE3E,yEAAyE;AACzE,qDAAqD;AAExC,QAAA,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgG1B,CAAA"}

package/dist/proto.d.ts

@@ -0,0 +1,19 @@
+import { Tabnas } from '@tabnas/parser';
+import { ProtoVersion } from './detect-version';
+import { FileDescriptorProto } from './descriptor';
+export interface ProtoOptions {
+    version: null | ProtoVersion;
+    reconcile: boolean;
+}
+type AnyTabnas = Tabnas & {
+    abnf?: Function;
+};
+declare const Proto: {
+    (tn: AnyTabnas, options?: Partial<ProtoOptions>): void;
+    defaults: ProtoOptions;
+};
+declare function toDescriptor(cst: any, options?: Partial<ProtoOptions>): FileDescriptorProto;
+declare function parse(src: string, options?: Partial<ProtoOptions>): FileDescriptorProto;
+export { Proto, parse, toDescriptor };
+export type { ProtoVersion };
+export * from './descriptor';

package/dist/proto.js

@@ -0,0 +1,64 @@
+"use strict";
+/* Copyright (c) 2026 Richard Rodger and other contributors, MIT License */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Proto = void 0;
+exports.parse = parse;
+exports.toDescriptor = toDescriptor;
+// @tabnas/proto — a Tabnas plugin that parses Protocol Buffers `.proto`
+// IDL (proto2, proto3, edition 2023/2024) into FileDescriptorProto-shaped
+// JSON. The version is auto-detected from the file's `syntax`/`edition`
+// declaration and/or supplied via the `version` option.
+const parser_1 = require("@tabnas/parser");
+const abnf_1 = require("@tabnas/abnf");
+const grammar_1 = require("./grammar");
+const build_descriptor_1 = require("./build-descriptor");
+const detect_version_1 = require("./detect-version");
+// The Tabnas plugin: installs the union proto grammar so the engine can
+// parse `.proto` source into a `{rule, src, kids}` CST. Use the exported
+// `parse()` / `toDescriptor()` to turn that CST into a FileDescriptorProto.
+const Proto = ((tn, _options) => {
+    // Proto drives parsing through @tabnas/abnf; ensure it is installed.
+    if ('function' !== typeof tn.abnf)
+        tn.use(abnf_1.abnf);
+    tn.abnf(grammar_1.grammarText, {
+        tag: 'proto',
+        start: 'proto',
+        wordKeywords: true,
+    });
+});
+exports.Proto = Proto;
+Proto.defaults = { version: null, reconcile: true };
+// Turn a parsed proto CST into a FileDescriptorProto, resolving the
+// version from the file's declaration and the supplied options.
+function toDescriptor(cst, options) {
+    const opts = { ...Proto.defaults, ...(options || {}) };
+    const first = (cst && cst.kids ? cst.kids : []).find((k) => k && k.rule);
+    const declared = first && 'syntaxOrEdition' === first.rule ? (0, detect_version_1.declaredVersion)(first) : null;
+    const version = (0, detect_version_1.resolveVersion)(declared, opts.version, opts.reconcile);
+    return (0, build_descriptor_1.buildFile)(cst, version);
+}
+// Convenience: parse a `.proto` source string to a FileDescriptorProto in
+// one call. Builds a fresh engine each time; for repeated parsing reuse an
+// engine via `const j = new Tabnas().use(Proto)` and call
+// `toDescriptor(j.parse(src), opts)`.
+function parse(src, options) {
+    const tn = new parser_1.Tabnas({ rewind: { history: 8192 } });
+    Proto(tn, options);
+    return toDescriptor(tn.parse(src), options);
+}
+__exportStar(require("./descriptor"), exports);
+//# sourceMappingURL=proto.js.map

package/dist/proto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proto.js","sourceRoot":"","sources":["../src/proto.ts"],"names":[],"mappings":";AAAA,2EAA2E;;;;;;;;;;;;;;;;;AAmE3D,sBAAK;AAAE,oCAAY;AAjEnC,wEAAwE;AACxE,0EAA0E;AAC1E,wEAAwE;AACxE,wDAAwD;AAExD,2CAAuC;AACvC,uCAAmC;AAEnC,uCAAuC;AACvC,yDAA8C;AAC9C,qDAEyB;AAczB,wEAAwE;AACxE,yEAAyE;AACzE,4EAA4E;AAC5E,MAAM,KAAK,GAAG,CAAC,CAAC,EAAa,EAAE,QAAgC,EAAE,EAAE;IACjE,qEAAqE;IACrE,IAAI,UAAU,KAAK,OAAO,EAAE,CAAC,IAAI;QAAE,EAAE,CAAC,GAAG,CAAC,WAAI,CAAC,CAC9C;IAAC,EAAE,CAAC,IAAiB,CAAC,qBAAW,EAAE;QAClC,GAAG,EAAE,OAAO;QACZ,KAAK,EAAE,OAAO;QACd,YAAY,EAAE,IAAI;KACnB,CAAC,CAAA;AACJ,CAAC,CAGA,CAAA;AAyBQ,sBAAK;AAvBd,KAAK,CAAC,QAAQ,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAA;AAEnD,oEAAoE;AACpE,gEAAgE;AAChE,SAAS,YAAY,CAAC,GAAQ,EAAE,OAA+B;IAC7D,MAAM,IAAI,GAAiB,EAAE,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE,CAAA;IACpE,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAA;IAC7E,MAAM,QAAQ,GACZ,KAAK,IAAI,iBAAiB,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAA,gCAAe,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;IAC3E,MAAM,OAAO,GAAG,IAAA,+BAAc,EAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IACtE,OAAO,IAAA,4BAAS,EAAC,GAAG,EAAE,OAAO,CAAC,CAAA;AAChC,CAAC;AAED,0EAA0E;AAC1E,2EAA2E;AAC3E,0DAA0D;AAC1D,sCAAsC;AACtC,SAAS,KAAK,CAAC,GAAW,EAAE,OAA+B;IACzD,MAAM,EAAE,GAAG,IAAI,eAAM,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,CAAc,CAAA;IACjE,KAAK,CAAC,EAAE,EAAE,OAAO,CAAC,CAAA;IAClB,OAAO,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAA;AAC7C,CAAC;AAID,+CAA4B"}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/build-descriptor.ts","../src/descriptor.ts","../src/detect-version.ts","../src/grammar.ts","../src/proto.ts"],"version":"6.0.3"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@tabnas/proto",
+  "version": "0.1.0",
+  "description": "Parse Protocol Buffers .proto IDL (proto2, proto3, edition 2023/2024) into FileDescriptorProto-shaped JSON, using the Tabnas parser and an ABNF grammar.",
+  "main": "dist/proto.js",
+  "type": "commonjs",
+  "types": "dist/proto.d.ts",
+  "homepage": "https://github.com/tabnas/proto",
+  "keywords": [
+    "protobuf",
+    "protocol-buffers",
+    "proto",
+    "proto2",
+    "proto3",
+    "editions",
+    "tabnas",
+    "parser",
+    "abnf",
+    "descriptor"
+  ],
+  "author": "Richard Rodger (http://richardrodger.com)",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/tabnas/proto.git"
+  },
+  "scripts": {
+    "test": "node --enable-source-maps --test \"dist-test/*.test.js\"",
+    "test-some": "node --enable-source-maps --test-name-pattern=\"$npm_config_pattern\" --test \"dist-test/*.test.js\"",
+    "test-watch": "node --test --watch dist-test/proto.test.js",
+    "embed": "node embed-grammar.js",
+    "example": "node examples/wire-poc/demo.js",
+    "example-test": "node --test examples/wire-poc/codec.test.js",
+    "watch": "tsc --build src test -w",
+    "build": "node embed-grammar.js && tsc --build src test",
+    "clean": "rm -rf node_modules dist dist-test yarn.lock package-lock.json",
+    "reset": "npm run clean && npm i && npm run build && npm test",
+    "repo-tag": "REPO_VERSION=`node -e \"console.log(require('./package').version)\"` && echo TAG: v$REPO_VERSION && git commit -a -m v$REPO_VERSION && git push && git tag v$REPO_VERSION && git push --tags;",
+    "repo-publish": "npm run clean && npm i && npm run repo-publish-quick",
+    "repo-publish-quick": "npm run build && npm run test && npm run repo-tag && npm publish --access public --registry https://registry.npmjs.org "
+  },
+  "license": "MIT",
+  "files": [
+    "src",
+    "dist",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@tabnas/abnf": "^0.2.0",
+    "@tabnas/parser": "^0.2.0"
+  },
+  "devDependencies": {
+    "@tabnas/abnf": "file:../../abnf/ts",
+    "@tabnas/parser": "^0.2.0",
+    "@types/node": "25.6.0",
+    "typescript": "6.0.3"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}