happyskills 0.53.0 → 1.0.0

package/src/integration/schema.test.js

@@ -0,0 +1,167 @@
+'use strict'
+/**
+ * Integration tests for `happyskills schema --json` — spec
+ * 260525-cli-default-json § 10. The schema command emits a machine-readable
+ * description of the entire CLI surface so a generic agent can learn every
+ * command, every error code, and every next_step.action in one call.
+ *
+ * Coverage:
+ *   - Envelope conforms to the closed schema (validated via parse_envelope).
+ *   - data.envelope_schema_version + data.envelope_schema_uri present.
+ *   - data.commands carries one entry per known CLI command, each with
+ *     name, audience, input, output, errors[].
+ *   - data.error_codes mirrors the closed enum from constants/error_codes.js.
+ *   - data.next_step_actions mirrors the closed action list.
+ *   - data.next_step_kinds is the six-element closed enum.
+ *   - --text mode produces a human listing (no JSON envelope).
+ */
+const { describe, it } = require('node:test')
+const assert = require('node:assert/strict')
+const { spawnSync } = require('child_process')
+const path = require('path')
+const {
+	parse_envelope,
+	assert_success_envelope,
+} = require('../schema/envelope_test_helpers')
+const { ERROR_CODE_LIST } = require('../constants/error_codes')
+const {
+	NEXT_STEP_ACTION_LIST,
+	NEXT_STEP_KINDS,
+} = require('../constants/next_step_actions')
+const { COMMANDS } = require('../constants')
+
+const CLI = path.resolve(__dirname, '../../bin/happyskills.js')
+const NODE = process.execPath
+
+const run = (args = [], env_override = {}) => {
+	const has_mode_flag = args.includes('--json') || args.includes('--text')
+	const final_args = has_mode_flag ? args : [...args, '--text']
+	const result = spawnSync(NODE, [CLI, ...final_args], {
+		env: { ...process.env, NO_COLOR: '1', HAPPYSKILLS_ENVELOPE_STRICT: '1', HAPPYSKILLS_API_URL: 'http://localhost:0', CI: '', ...env_override },
+		encoding: 'utf-8',
+		timeout: 10000,
+	})
+	return { stdout: result.stdout || '', stderr: result.stderr || '', code: result.status }
+}
+
+describe('happyskills schema --json', () => {
+	it('emits a success envelope with command=schema', () => {
+		const { stdout, code } = run(['schema', '--json'])
+		assert.strictEqual(code, 0)
+		const env = parse_envelope(stdout, 'schema --json')
+		assert_success_envelope(env, 'schema --json')
+		assert.strictEqual(env.meta.command, 'schema')
+		assert.strictEqual(env.meta.envelope_schema_version, '1.0.0')
+	})
+
+	it('data.envelope_schema_version + envelope_schema_uri are exposed', () => {
+		const { stdout } = run(['schema', '--json'])
+		const env = parse_envelope(stdout, 'schema --json envelope meta')
+		assert.strictEqual(env.data.envelope_schema_version, '1.0.0')
+		assert.strictEqual(env.data.envelope_schema_uri, 'https://schemas.happyskills.dev/envelope/v1.json')
+		assert.ok(typeof env.data.cli_version === 'string')
+	})
+
+	it('data.commands covers every known CLI command (one entry each)', () => {
+		const { stdout } = run(['schema', '--json'])
+		const env = parse_envelope(stdout, 'schema --json commands')
+		assert.ok(Array.isArray(env.data.commands), 'data.commands must be an array')
+		assert.ok(env.data.commands.length > 0)
+		const names = new Set(env.data.commands.map(c => c.name))
+		// schema itself is a command — it must be in the registry.
+		assert.ok(names.has('schema'), 'schema must list itself')
+		// Spot-check that the central commands are present.
+		for (const cmd of ['install', 'uninstall', 'search', 'release', 'reconcile', 'whoami']) {
+			assert.ok(names.has(cmd), `commands must include ${cmd}`)
+		}
+		// And every name in COMMANDS appears in the schema (modulo aliases).
+		for (const cmd of COMMANDS) {
+			assert.ok(names.has(cmd), `every CLI command must export schema metadata: missing ${cmd}`)
+		}
+	})
+
+	it('each command schema entry carries the required fields', () => {
+		const { stdout } = run(['schema', '--json'])
+		const env = parse_envelope(stdout, 'schema --json command shape')
+		for (const cmd of env.data.commands) {
+			assert.ok(typeof cmd.name === 'string' && cmd.name.length > 0, `command.name must be set: ${JSON.stringify(cmd)}`)
+			assert.ok(['consumer', 'author', 'account', 'system'].includes(cmd.audience), `command.audience must be a known group, got ${cmd.audience} for ${cmd.name}`)
+			assert.ok(typeof cmd.purpose === 'string' && cmd.purpose.length > 0, `command.purpose must be set for ${cmd.name}`)
+			assert.ok(typeof cmd.mutation === 'boolean', `command.mutation must be a boolean for ${cmd.name}`)
+			assert.ok(cmd.input && typeof cmd.input === 'object', `command.input must be an object for ${cmd.name}`)
+			assert.ok(cmd.output && typeof cmd.output === 'object', `command.output must be an object for ${cmd.name}`)
+			assert.ok(Array.isArray(cmd.errors), `command.errors must be an array for ${cmd.name}`)
+		}
+	})
+
+	it('every command.errors[].code is in the closed enum, and the kind/action pair is valid', () => {
+		const { stdout } = run(['schema', '--json'])
+		const env = parse_envelope(stdout, 'schema --json error refs')
+		const error_set  = new Set(ERROR_CODE_LIST)
+		const action_set = new Set(NEXT_STEP_ACTION_LIST)
+		const kind_set   = new Set(NEXT_STEP_KINDS)
+		for (const cmd of env.data.commands) {
+			for (const e of cmd.errors) {
+				assert.ok(error_set.has(e.code), `${cmd.name}.errors[].code "${e.code}" not in closed enum`)
+				if (e.next_step) {
+					assert.ok(kind_set.has(e.next_step.kind), `${cmd.name}: kind "${e.next_step.kind}" not in closed enum`)
+					assert.ok(action_set.has(e.next_step.action), `${cmd.name}: action "${e.next_step.action}" not in closed enum`)
+				}
+			}
+		}
+	})
+
+	it('data.error_codes mirrors the closed error-code enum', () => {
+		const { stdout } = run(['schema', '--json'])
+		const env = parse_envelope(stdout, 'schema --json error_codes')
+		assert.ok(Array.isArray(env.data.error_codes))
+		// The schema output may carry richer per-code metadata; we only assert
+		// the closed-set membership.
+		const codes = new Set(env.data.error_codes.map(e => typeof e === 'string' ? e : e.code))
+		for (const c of ERROR_CODE_LIST) {
+			assert.ok(codes.has(c), `data.error_codes must include ${c}`)
+		}
+	})
+
+	it('data.next_step_actions mirrors the closed action enum (with kind annotation)', () => {
+		const { stdout } = run(['schema', '--json'])
+		const env = parse_envelope(stdout, 'schema --json actions')
+		assert.ok(Array.isArray(env.data.next_step_actions))
+		const action_names = new Set(env.data.next_step_actions.map(a => typeof a === 'string' ? a : a.action))
+		for (const a of NEXT_STEP_ACTION_LIST) {
+			assert.ok(action_names.has(a), `data.next_step_actions must include ${a}`)
+		}
+		// Each entry should annotate which kind it belongs to (spec § 7.1).
+		for (const entry of env.data.next_step_actions) {
+			if (typeof entry === 'object' && entry !== null) {
+				assert.ok(NEXT_STEP_KINDS.includes(entry.kind), `${entry.action}: kind "${entry.kind}" not in closed enum`)
+			}
+		}
+	})
+
+	it('data.next_step_kinds is the six-element closed enum, in canonical order', () => {
+		const { stdout } = run(['schema', '--json'])
+		const env = parse_envelope(stdout, 'schema --json kinds')
+		assert.deepStrictEqual(
+			env.data.next_step_kinds,
+			['recovery', 'clarification', 'decision', 'confirmation', 'continuation', 'routing']
+		)
+	})
+
+	it('--text mode emits a human-readable listing (no JSON envelope)', () => {
+		const { stdout, code } = run(['schema', '--text'])
+		assert.strictEqual(code, 0)
+		// Not an envelope — must not start with `{`.
+		assert.ok(!stdout.trimStart().startsWith('{'), 'schema --text must not emit JSON')
+		// At minimum, the listing names a recognisable section header and at
+		// least one core command.
+		assert.match(stdout, /install/, '--text listing should mention `install`')
+	})
+
+	it('--help exits 0 and describes the schema command', () => {
+		const { stdout, code } = run(['schema', '--help'])
+		assert.strictEqual(code, 0)
+		assert.match(stdout, /schema/i)
+		assert.match(stdout, /--json/)
+	})
+})

package/src/schema/envelope.schema.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.happyskills.dev/envelope/v1.json",
+  "title": "HappySkills Response Envelope",
+  "description": "The canonical CLI response envelope. Spec 260525-cli-default-json § 4.",
+  "type": "object",
+  "required": ["ok", "data", "error", "next_step", "warnings", "meta"],
+  "additionalProperties": false,
+  "properties": {
+    "ok":        { "type": "boolean" },
+    "data":      { "type": "object" },
+    "error":     { "$ref": "#/$defs/Error" },
+    "next_step": { "$ref": "#/$defs/NextStep" },
+    "warnings":  { "type": "array", "items": { "$ref": "#/$defs/Warning" } },
+    "meta":      { "$ref": "#/$defs/Meta" }
+  },
+  "$defs": {
+    "Error": {
+      "type": "object",
+      "properties": {
+        "code":    { "type": "string" },
+        "message": { "type": "string", "minLength": 1 },
+        "details": { "type": "object" }
+      },
+      "dependentRequired": {
+        "code":    ["message"],
+        "message": ["code"]
+      },
+      "additionalProperties": true
+    },
+    "NextStep": {
+      "type": "object",
+      "properties": {
+        "kind":         { "type": "string", "enum": ["recovery", "clarification", "decision", "confirmation", "continuation", "routing"] },
+        "action":       { "type": "string" },
+        "instructions": { "type": "string", "minLength": 1 },
+        "context":      { "type": "object" },
+        "principal_authorization_required": { "type": "boolean" },
+        "route_to_skill": { "type": "string" }
+      },
+      "dependentRequired": {
+        "kind":         ["action", "instructions"],
+        "action":       ["kind", "instructions"],
+        "instructions": ["kind", "action"]
+      },
+      "additionalProperties": false
+    },
+    "Warning": {
+      "type": "object",
+      "required": ["code", "message"],
+      "properties": {
+        "code":    { "type": "string" },
+        "message": { "type": "string" }
+      },
+      "additionalProperties": false
+    },
+    "Meta": {
+      "type": "object",
+      "required": ["command", "exit_code", "envelope_schema_version"],
+      "properties": {
+        "command":                 { "type": "string" },
+        "cli_version":             { "type": "string" },
+        "api_version":             { "type": "string" },
+        "exit_code":               { "type": "integer", "minimum": 0 },
+        "envelope_schema_version": { "type": "string" },
+        "workspace":               { "type": "string" },
+        "request_id":              { "type": "string" },
+        "min_cli_version":         { "type": "string" }
+      },
+      "additionalProperties": false
+    }
+  }
+}

package/src/schema/envelope_test_helpers.js

@@ -0,0 +1,94 @@
+'use strict'
+// Shared assertions for the CLI envelope. Every --json CLI output produced
+// by the integration test suite passes through assert_envelope. The pure-JS
+// unit tests reuse the same primitives so the rules stay in one place.
+//
+// All helpers throw node:assert AssertionError on failure — they are not
+// catch_errors-wrapped.
+
+const assert = require('node:assert/strict')
+const { validate_envelope } = require('./envelope_validator')
+
+const format_errors = (errors) =>
+	errors.map(e => `  - ${e.path || '<root>'}: ${e.message}`).join('\n')
+
+// Parse stdout as JSON and validate as an envelope. Throws on either step.
+const parse_envelope = (stdout, label = '') => {
+	let parsed
+	try {
+		parsed = JSON.parse(stdout)
+	} catch (e) {
+		assert.fail(`${label ? label + ': ' : ''}stdout is not valid JSON:\n${stdout}`)
+	}
+	const { ok, errors } = validate_envelope(parsed)
+	if (!ok) {
+		assert.fail(
+			`${label ? label + ': ' : ''}envelope failed validation:\n${format_errors(errors)}\n` +
+			`envelope:\n${JSON.stringify(parsed, null, 2)}`
+		)
+	}
+	return parsed
+}
+
+// Validate an already-parsed envelope object.
+const assert_envelope = (env, label = '') => {
+	const { ok, errors } = validate_envelope(env)
+	if (!ok) {
+		assert.fail(
+			`${label ? label + ': ' : ''}envelope failed validation:\n${format_errors(errors)}\n` +
+			`envelope:\n${JSON.stringify(env, null, 2)}`
+		)
+	}
+	return env
+}
+
+const assert_success_envelope = (env, label = '') => {
+	assert_envelope(env, label)
+	assert.strictEqual(env.ok, true, `${label}: expected ok=true, got ${env.ok}`)
+	assert.deepStrictEqual(env.error, {}, `${label}: success envelope must have error={}`)
+	assert.strictEqual(env.meta.exit_code, 0, `${label}: success must have meta.exit_code=0`)
+	return env
+}
+
+const assert_error_envelope = (env, expected_code, label = '') => {
+	assert_envelope(env, label)
+	assert.strictEqual(env.ok, false, `${label}: expected ok=false, got ${env.ok}`)
+	assert.ok(env.error && env.error.code, `${label}: error envelope must have error.code`)
+	if (expected_code) {
+		assert.strictEqual(
+			env.error.code,
+			expected_code,
+			`${label}: expected error.code=${expected_code}, got ${env.error.code}`
+		)
+	}
+	assert.notStrictEqual(env.meta.exit_code, 0, `${label}: error envelope must not have exit_code=0`)
+	return env
+}
+
+const assert_has_next_step = (env, expected_action, label = '') => {
+	assert_envelope(env, label)
+	assert.ok(env.next_step && env.next_step.action, `${label}: next_step must be populated`)
+	if (expected_action) {
+		assert.strictEqual(
+			env.next_step.action,
+			expected_action,
+			`${label}: expected next_step.action=${expected_action}, got ${env.next_step.action}`
+		)
+	}
+	return env
+}
+
+const assert_no_next_step = (env, label = '') => {
+	assert_envelope(env, label)
+	assert.deepStrictEqual(env.next_step, {}, `${label}: expected next_step={}`)
+	return env
+}
+
+module.exports = {
+	parse_envelope,
+	assert_envelope,
+	assert_success_envelope,
+	assert_error_envelope,
+	assert_has_next_step,
+	assert_no_next_step,
+}

package/src/schema/envelope_validator.js

@@ -0,0 +1,239 @@
+'use strict'
+// Hand-rolled envelope validator. Per spec 260525-cli-default-json § 13
+// Session 1b: zero new npm runtime deps. Enforces only the load-bearing
+// invariants — top-level shape, closed enums, dependentRequired clusters,
+// and the derived `ok === (error.code === undefined)` rule. Domain extras
+// inside data / error / next_step.context are accepted permissively
+// (additionalProperties: true) so per-command payloads don't need bespoke
+// schemas.
+//
+// The validator returns a structured report; it never throws on invalid
+// input. Callers (test helpers, exit_with_error in Session 2) decide
+// whether to fail loudly or surface warnings.
+
+const { ERROR_CODE_SET } = require('../constants/error_codes')
+const {
+	NEXT_STEP_ACTION_SET,
+	NEXT_STEP_KIND_SET,
+	ACTION_KIND,
+} = require('../constants/next_step_actions')
+
+const ENVELOPE_SCHEMA_VERSION = '1.0.0'
+
+const TOP_LEVEL_KEYS = ['ok', 'data', 'error', 'next_step', 'warnings', 'meta']
+const TOP_LEVEL_KEY_SET = new Set(TOP_LEVEL_KEYS)
+const ERROR_REQUIRED_KEYS     = ['code', 'message']
+const NEXT_STEP_REQUIRED_KEYS = ['kind', 'action', 'instructions']
+
+const is_plain_object = (x) =>
+	x !== null && typeof x === 'object' && !Array.isArray(x)
+
+const push = (errors, path, msg) => {
+	errors.push({ path, message: msg })
+}
+
+const validate_error_slot = (error, errors) => {
+	if (!is_plain_object(error)) {
+		push(errors, 'error', 'must be an object (use {} when no error)')
+		return
+	}
+	const present = ERROR_REQUIRED_KEYS.filter(k => k in error)
+	if (present.length === 0) return // empty form is valid
+	// dependentRequired: code <-> message travel together.
+	if (present.length !== ERROR_REQUIRED_KEYS.length) {
+		const missing = ERROR_REQUIRED_KEYS.filter(k => !(k in error))
+		push(
+			errors,
+			'error',
+			`populated error must include both code and message (missing: ${missing.join(', ')})`
+		)
+	}
+	if ('code' in error) {
+		if (typeof error.code !== 'string') {
+			push(errors, 'error.code', 'must be a string')
+		} else if (!ERROR_CODE_SET.has(error.code)) {
+			push(errors, 'error.code', `not in the closed enum: ${error.code}`)
+		}
+	}
+	if ('message' in error) {
+		if (typeof error.message !== 'string' || error.message.length === 0) {
+			push(errors, 'error.message', 'must be a non-empty string')
+		}
+	}
+	if ('details' in error && !is_plain_object(error.details)) {
+		push(errors, 'error.details', 'must be an object when present')
+	}
+}
+
+const validate_next_step_slot = (ns, errors) => {
+	if (!is_plain_object(ns)) {
+		push(errors, 'next_step', 'must be an object (use {} when no follow-up)')
+		return
+	}
+	const present = NEXT_STEP_REQUIRED_KEYS.filter(k => k in ns)
+	if (present.length === 0) {
+		// Empty form valid, but stray sibling keys aren't.
+		for (const k of Object.keys(ns)) {
+			if (!['principal_authorization_required', 'route_to_skill', 'context'].includes(k)) {
+				push(errors, `next_step.${k}`, 'unexpected key in empty next_step (only the three-key cluster is allowed when populated)')
+			}
+		}
+		return
+	}
+	if (present.length !== NEXT_STEP_REQUIRED_KEYS.length) {
+		const missing = NEXT_STEP_REQUIRED_KEYS.filter(k => !(k in ns))
+		push(
+			errors,
+			'next_step',
+			`populated next_step must include kind, action, instructions (missing: ${missing.join(', ')})`
+		)
+	}
+	if ('kind' in ns) {
+		if (typeof ns.kind !== 'string') {
+			push(errors, 'next_step.kind', 'must be a string')
+		} else if (!NEXT_STEP_KIND_SET.has(ns.kind)) {
+			push(errors, 'next_step.kind', `not in the closed enum: ${ns.kind}`)
+		}
+	}
+	if ('action' in ns) {
+		if (typeof ns.action !== 'string') {
+			push(errors, 'next_step.action', 'must be a string')
+		} else if (!NEXT_STEP_ACTION_SET.has(ns.action)) {
+			push(errors, 'next_step.action', `not in the closed enum: ${ns.action}`)
+		}
+	}
+	if ('kind' in ns && 'action' in ns && NEXT_STEP_ACTION_SET.has(ns.action)) {
+		const expected_kind = ACTION_KIND[ns.action]
+		if (expected_kind && expected_kind !== ns.kind) {
+			push(
+				errors,
+				'next_step',
+				`action "${ns.action}" belongs to kind "${expected_kind}", not "${ns.kind}"`
+			)
+		}
+	}
+	if ('instructions' in ns) {
+		if (typeof ns.instructions !== 'string' || ns.instructions.length === 0) {
+			push(errors, 'next_step.instructions', 'must be a non-empty string')
+		}
+	}
+	if ('context' in ns && !is_plain_object(ns.context)) {
+		push(errors, 'next_step.context', 'must be an object when present')
+	}
+	if ('principal_authorization_required' in ns
+		&& typeof ns.principal_authorization_required !== 'boolean') {
+		push(errors, 'next_step.principal_authorization_required', 'must be a boolean')
+	}
+	if ('route_to_skill' in ns && typeof ns.route_to_skill !== 'string') {
+		push(errors, 'next_step.route_to_skill', 'must be a string')
+	}
+}
+
+const validate_warnings_slot = (warnings, errors) => {
+	if (!Array.isArray(warnings)) {
+		push(errors, 'warnings', 'must be an array (use [] when none)')
+		return
+	}
+	warnings.forEach((w, i) => {
+		if (!is_plain_object(w)) {
+			push(errors, `warnings[${i}]`, 'must be an object')
+			return
+		}
+		if (typeof w.code !== 'string' || w.code.length === 0) {
+			push(errors, `warnings[${i}].code`, 'must be a non-empty string')
+		}
+		if (typeof w.message !== 'string' || w.message.length === 0) {
+			push(errors, `warnings[${i}].message`, 'must be a non-empty string')
+		}
+	})
+}
+
+const validate_meta_slot = (meta, errors) => {
+	if (!is_plain_object(meta)) {
+		push(errors, 'meta', 'must be an object')
+		return
+	}
+	if (typeof meta.command !== 'string' || meta.command.length === 0) {
+		push(errors, 'meta.command', 'must be a non-empty string')
+	}
+	if (!Number.isInteger(meta.exit_code) || meta.exit_code < 0) {
+		push(errors, 'meta.exit_code', 'must be a non-negative integer')
+	}
+	if (typeof meta.envelope_schema_version !== 'string'
+		|| meta.envelope_schema_version.length === 0) {
+		push(errors, 'meta.envelope_schema_version', 'must be a non-empty string')
+	}
+	if ('cli_version' in meta && typeof meta.cli_version !== 'string') {
+		push(errors, 'meta.cli_version', 'must be a string when present')
+	}
+	if ('api_version' in meta && typeof meta.api_version !== 'string') {
+		push(errors, 'meta.api_version', 'must be a string when present')
+	}
+	if ('workspace' in meta && typeof meta.workspace !== 'string') {
+		push(errors, 'meta.workspace', 'must be a string when present')
+	}
+	if ('request_id' in meta && typeof meta.request_id !== 'string') {
+		push(errors, 'meta.request_id', 'must be a string when present')
+	}
+	if ('min_cli_version' in meta && typeof meta.min_cli_version !== 'string') {
+		push(errors, 'meta.min_cli_version', 'must be a string when present')
+	}
+}
+
+const validate_envelope = (env) => {
+	const errors = []
+
+	if (!is_plain_object(env)) {
+		return { ok: false, errors: [{ path: '', message: 'envelope must be an object' }] }
+	}
+
+	// Top-level keys: exactly six, no extras.
+	for (const k of TOP_LEVEL_KEYS) {
+		if (!(k in env)) push(errors, k, 'top-level key is required')
+	}
+	for (const k of Object.keys(env)) {
+		if (!TOP_LEVEL_KEY_SET.has(k)) {
+			push(errors, k, 'unexpected top-level key (envelope keys are closed)')
+		}
+	}
+
+	// Per-slot types.
+	if ('ok' in env && typeof env.ok !== 'boolean') {
+		push(errors, 'ok', 'must be a boolean')
+	}
+	if ('data' in env && !is_plain_object(env.data)) {
+		push(errors, 'data', 'must be an object (never null, never array)')
+	}
+	if ('error' in env) validate_error_slot(env.error, errors)
+	if ('next_step' in env) validate_next_step_slot(env.next_step, errors)
+	if ('warnings' in env) validate_warnings_slot(env.warnings, errors)
+	if ('meta' in env) validate_meta_slot(env.meta, errors)
+
+	// Derived invariant: ok === (error.code === undefined).
+	if (typeof env.ok === 'boolean' && is_plain_object(env.error)) {
+		const has_code = 'code' in env.error
+		if (env.ok === has_code) {
+			push(
+				errors,
+				'ok',
+				`derived invariant violated: ok=${env.ok} but error.code ${has_code ? 'is' : 'is not'} present`
+			)
+		}
+	}
+
+	// meta.exit_code mirror: when ok is true, exit_code must be 0.
+	if (env.ok === true && is_plain_object(env.meta) && env.meta.exit_code !== 0) {
+		push(errors, 'meta.exit_code', `must be 0 when ok=true, got ${env.meta.exit_code}`)
+	}
+	if (env.ok === false && is_plain_object(env.meta) && env.meta.exit_code === 0) {
+		push(errors, 'meta.exit_code', 'must be non-zero when ok=false')
+	}
+
+	return { ok: errors.length === 0, errors }
+}
+
+module.exports = {
+	validate_envelope,
+	ENVELOPE_SCHEMA_VERSION,
+	TOP_LEVEL_KEYS,
+}