@bedrock-rbx/core 0.1.0-beta.1

package/dist/define-config-D-LAhfSJ.d.mts

@@ -0,0 +1,1731 @@
+import { Result } from "@bedrock-rbx/ocale";
+import { SocialLink } from "@bedrock-rbx/ocale/universes";
+
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/union-to-intersection.d.ts
+/**
+Convert a union type to an intersection type.
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown // The union type is used as the only argument to a function since the union
+// of function arguments is an intersection.
+? (distributedUnion: Union) => void // This won't happen.
+: never // Infer the `Intersection` type since TypeScript represents the positional
+// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void) // The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+? Intersection & Union : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/keys-of-union.d.ts
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+type KeysOfUnion<ObjectType> = // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-any.d.ts
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+type Admin = {
+	name: string;
+	surname?: string;
+};
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice',
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD,
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+: never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<
+	Entity extends object,
+	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
+>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
+
+type User = {
+	name: string;
+	surname: string;
+	luckyNumber?: number;
+};
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+
+// @ts-expect-error
+const validator3 = createValidation<User>('luckyNumber', value => value > 0);
+// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/if.d.ts
+/**
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
+
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
+
+@example
+```
+import type {If} from 'type-fest';
+
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import type {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import type {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
+
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/unknown-array.d.ts
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+type UnknownArray = readonly unknown[];
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/internal/array.d.ts
+/**
+Returns whether the given array `T` is readonly.
+*/
+type IsArrayReadonly<T extends UnknownArray> = If<IsNever<T>, false, T extends unknown[] ? false : true>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/simplify.d.ts
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/omit-index-signature.d.ts
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+// @ts-expect-error
+const keyed: Record<'foo', unknown> = {}; // Error
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type Example = {
+	// These index signatures will be removed.
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+//=> {foo: 'bar'; qux?: 'baz'}
+```
+
+@see {@link PickIndexSignature}
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/pick-index-signature.d.ts
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see {@link OmitIndexSignature}
+@category Object
+*/
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: number;
+};
+
+type Bar = {
+	a: number; // Conflicts with Foo['a']
+	c: boolean;
+};
+
+// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
+type WithIntersection = (Foo & Bar)['a'];
+//=> never
+
+// With `Merge`, `a` is cleanly overridden to `number`.
+type WithMerge = Merge<Foo, Bar>['a'];
+//=> number
+```
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+};
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+//=> {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
+
+@see {@link ObjectMerge}
+@category Object
+*/
+type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
+? Source extends unknown // For distributing `Source`
+? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+: never;
+// Should never happen
+type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/internal/object.d.ts
+/**
+Works similar to the built-in `Pick` utility type, except for the following differences:
+- Distributes over union types and allows picking keys from any member of the union type.
+- Primitives types are returned as-is.
+- Picks all keys if `Keys` is `any`.
+- Doesn't pick `number` from a `string` index signature.
+
+@example
+```
+type ImageUpload = {
+	url: string;
+	size: number;
+	thumbnailUrl: string;
+};
+
+type VideoUpload = {
+	url: string;
+	duration: number;
+	encodingFormat: string;
+};
+
+// Distributes over union types and allows picking keys from any member of the union type
+type MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, "url" | "size" | "duration">;
+//=> {url: string; size: number} | {url: string; duration: number}
+
+// Primitive types are returned as-is
+type Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;
+//=> string | number
+
+// Picks all keys if `Keys` is `any`
+type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
+//=> {a: 1; b: 2} | {c: 3}
+
+// Doesn't pick `number` from a `string` index signature
+type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
+//=> {}
+*/
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/except.d.ts
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type ExceptOptions = {
+  /**
+  Disallow assigning non-specified properties.
+  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+  	@default false
+  */
+  requireExactProps?: boolean;
+};
+type DefaultExceptOptions = {
+  requireExactProps: false;
+};
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+// @ts-expect-error
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+// errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<'b', never>>
+
+// @ts-expect-error
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+// errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> {[x: string]: string; [x: number]: string}
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayloadFixed = Except<UserData, 'email'>;
+//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/set-required.d.ts
+/**
+Create a type that makes the given keys required, while keeping the remaining keys as is.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
+
+@example
+```
+import type {SetRequired} from 'type-fest';
+
+type Foo = {
+	a?: number;
+	b: string;
+	c?: boolean;
+};
+
+type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
+//=> {a?: number; b: string; c: boolean}
+
+// Set specific indices in an array to be required.
+type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
+//=> [number, number, number?]
+```
+
+@category Object
+*/
+type SetRequired<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetRequired<BaseType, Keys>;
+type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray> : never : Simplify< // Pick just the keys that are optional from the base type.
+Except<BaseType, Keys> // Pick the keys that should be required from the base type and make them required.
+& Required<HomomorphicPick<BaseType, Keys>>>;
+/**
+Remove the optional modifier from the specified keys in an array.
+*/
+type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown // For distributing `TArray` when it's a union
+? keyof TArray & `${number}` extends never // Exit if `TArray` is empty (e.g., []), or
+// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+? [...Accumulator, ...TArray] : TArray extends readonly [(infer First)?, ...infer Rest] ? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
+? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
+? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]> // If the current element is optional, but it doesn't need to be required,
+// then we can exit early, since no further elements can now be made required.
+: [...Accumulator, ...TArray] : SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]> : never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+: never; // Should never happen
+//#endregion
+//#region src/core/config-error.d.ts
+/**
+* Single validation problem reported by the schema validator. `path` is the
+* sequence of keys and indices into the config root; `message` is a
+* human-readable explanation.
+*
+* @example
+*
+* ```ts
+* import type { ConfigValidationIssue } from "@bedrock-rbx/core";
+*
+* const issue: ConfigValidationIssue = {
+*     message: "must be a number",
+*     path: ["passes", "vip-pass", "price"],
+* };
+*
+* expect(issue.path).toStrictEqual(["passes", "vip-pass", "price"]);
+* ```
+*/
+interface ConfigValidationIssue {
+  /** Human-readable explanation of why this field failed validation. */
+  readonly message: string;
+  /** Sequence of keys from the config root to the offending field. */
+  readonly path: ReadonlyArray<string>;
+}
+/**
+* Failure surfaced by `loadConfig` when a project config cannot be resolved,
+* parsed, or validated. Plain-data discriminated union; narrow on `kind`
+* rather than using `instanceof`.
+*
+* Current cases:
+* - `fileNotFound` - no `bedrock.config.*` (or other c12-discovered file)
+*   was found starting from the working directory.
+* - `parseFailed` - a config file was found but could not be parsed (for
+*   example, malformed YAML or JSON). `message` carries the underlying
+*   parser message verbatim.
+* - `validationFailed` - a config file was found and parsed, but its content
+*   did not satisfy the runtime schema. `issues` attributes each problem to
+*   a field path so callers can point at the offending entry.
+* - `configFunctionFailed` - a function-form config threw or its returned
+*   promise rejected while being invoked. `message` carries the thrown
+*   error's message verbatim.
+* - `luauRuntimeMissing` - a `bedrock.config.luau` file was found but the
+*   `lute` runtime needed to evaluate it could not be located on PATH or
+*   via the `BEDROCK_LUTE_PATH` environment variable. `hint` carries an
+*   actionable install message.
+*
+* @example
+*
+* ```ts
+* import type { ConfigError } from "@bedrock-rbx/core";
+*
+* function describe(err: ConfigError): string {
+*     switch (err.kind) {
+*         case "fileNotFound": {
+*             return `no bedrock config under ${err.searchedFrom}`;
+*         }
+*         case "parseFailed": {
+*             return `${err.sourceFile}: ${err.message}`;
+*         }
+*         case "configFunctionFailed": {
+*             return `${err.sourceFile}: config function threw: ${err.message}`;
+*         }
+*         case "validationFailed": {
+*             const first = err.issues[0];
+*             return first
+*                 ? `${err.sourceFile}: ${first.path.join(".")} ${first.message}`
+*                 : `${err.sourceFile}: invalid`;
+*         }
+*         case "luauRuntimeMissing": {
+*             return `${err.sourceFile}: ${err.hint}`;
+*         }
+*     }
+* }
+*
+* expect(describe({ kind: "fileNotFound", searchedFrom: "/proj" })).toBe(
+*     "no bedrock config under /proj",
+* );
+* expect(
+*     describe({
+*         kind: "parseFailed",
+*         sourceFile: "bedrock.config.yaml",
+*         message: "unexpected end of the stream",
+*     }),
+* ).toBe("bedrock.config.yaml: unexpected end of the stream");
+* expect(
+*     describe({
+*         kind: "configFunctionFailed",
+*         sourceFile: "bedrock.config.ts",
+*         message: "boom",
+*     }),
+* ).toBe("bedrock.config.ts: config function threw: boom");
+* expect(
+*     describe({
+*         kind: "validationFailed",
+*         sourceFile: "bedrock.config.ts",
+*         issues: [{ path: ["passes", "vip", "price"], message: "must be a number" }],
+*     }),
+* ).toBe("bedrock.config.ts: passes.vip.price must be a number");
+* expect(
+*     describe({
+*         kind: "luauRuntimeMissing",
+*         sourceFile: "bedrock.config.luau",
+*         hint: "install lute via mise",
+*     }),
+* ).toBe("bedrock.config.luau: install lute via mise");
+* ```
+*/
+type ConfigError = {
+  readonly hint: string;
+  readonly kind: "luauRuntimeMissing";
+  readonly sourceFile: string;
+} | {
+  readonly issues: ReadonlyArray<ConfigValidationIssue>;
+  readonly kind: "validationFailed";
+  readonly sourceFile: string;
+} | {
+  readonly kind: "configFunctionFailed";
+  readonly message: string;
+  readonly sourceFile: string;
+} | {
+  readonly kind: "fileNotFound";
+  readonly searchedFrom: string;
+} | {
+  readonly kind: "parseFailed";
+  readonly message: string;
+  readonly sourceFile: string;
+};
+//#endregion
+//#region src/core/schema.d.ts
+/**
+* Body of a single entry in the `passes` collection. Keys in the parent
+* record are `ResourceKey`-shaped strings enforced at schema validation.
+*/
+interface GamePassEntry {
+  /** Name shown on the Roblox storefront. */
+  name: string;
+  /** Description shown on the game-pass detail page. */
+  description: string;
+  /**
+  * Locale-keyed icon paths. The map shape mirrors `UniverseEntry.icon`
+  * so authors see a single vocabulary across icon-bearing kinds; v1
+  * only accepts the `"en-us"` key. The Roblox game-pass API is
+  * monolingual, so the `"en-us"` icon is the only one ever uploaded.
+  */
+  icon: Record<"en-us", string>;
+  /** Robux price, or omitted / `undefined` for off-sale. */
+  price?: number | undefined;
+}
+/**
+* Body of a single entry in the `products` collection. Keys in the parent
+* record are `ResourceKey`-shaped strings enforced at schema validation.
+*/
+interface DeveloperProductEntry {
+  /** Name shown on the Roblox storefront. */
+  name: string;
+  /** Description shown on the developer-product detail page. */
+  description: string;
+  /**
+  * Locale-keyed icon paths. Mirrors `GamePassEntry.icon` and
+  * `UniverseEntry.icon`; the Roblox developer-product API is monolingual,
+  * so the `"en-us"` icon is the only one ever uploaded.
+  */
+  icon?: Record<"en-us", string>;
+  /**
+  * Whether Roblox-managed regional pricing applies to the product.
+  * Tri-state: omit (or set `undefined`) to leave the flag unmanaged;
+  * setting `true` or `false` is propagated to Roblox on every deploy.
+  */
+  isRegionalPricingEnabled?: boolean | undefined;
+  /**
+  * Robux price. Omit (or set `undefined`) for an off-sale product;
+  * re-adding the field puts the product back on sale on the next deploy.
+  */
+  price?: number | undefined;
+  /**
+  * Whether the product appears on the universe's external store page.
+  * Tri-state: omit (or set `undefined`) to leave the flag unmanaged.
+  * The Roblox v2 create endpoint does not accept this field, so the
+  * driver applies it via a follow-up PATCH after the create POST.
+  */
+  storePageEnabled?: boolean | undefined;
+}
+/**
+* Body of a single entry under the root `places` collection. Carries the
+* file-path environments share plus the optional Open-Cloud-supported
+* metadata fields. The Roblox `placeId` is environment-specific and lives
+* on each per-environment overlay so the same `.rbxl` file can publish to
+* different places across staging, production, and so on.
+*/
+interface PlaceEntry {
+  /** User-facing description shown on the place's detail page. */
+  description?: string | undefined;
+  /** User-facing place name shown on the Roblox storefront. */
+  displayName?: string | undefined;
+  /** Path to the `.rbxl` or `.rbxlx` file; handed to `readFile` verbatim by `buildDesired`. */
+  filePath: string;
+  /** Maximum players per server; positive integer. */
+  serverSize?: number | undefined;
+}
+/**
+* Body of a places entry after `selectEnvironment` has merged the
+* matching per-environment overlay onto the root entry. `filePath` flows
+* from the root (or an overlay override), `placeId` is supplied by the
+* per-environment overlay, and the optional metadata fields fall through
+* from the root unless overridden per-environment.
+*
+* `placeId` is user-supplied because Open Cloud cannot mint places; the
+* place must already exist in Roblox before Bedrock can publish versions
+* to it.
+*/
+interface ResolvedPlaceEntry {
+  /** User-facing description shown on the place's detail page. */
+  description?: string | undefined;
+  /** User-facing place name shown on the Roblox storefront. */
+  displayName?: string | undefined;
+  /** Path to the `.rbxl` or `.rbxlx` file; handed to `readFile` verbatim by `buildDesired`. */
+  filePath: string;
+  /** Existing Roblox place ID. */
+  placeId: string;
+  /** Maximum players per server; positive integer. */
+  serverSize?: number | undefined;
+}
+/**
+* Body of the singleton `universe` block. Bedrock synthesizes the
+* `ResourceKey` (`"main"`) in `flattenConfig`, so user config supplies
+* only the existing `universeId` plus any managed fields they want
+* bedrock to own. Fields omitted here remain unmanaged (the diff treats
+* them as non-drift and the driver omits them from the `updateMask`).
+*
+* `universeId` is user-supplied because Open Cloud cannot mint universes;
+* the universe must already exist in Roblox before bedrock can reconcile
+* its configuration. Declare `universeId` either here at the root (which
+* applies to every environment) or under each `environments[name].universe`
+* overlay, but never both: the schema rejects a config that sets it in
+* both places, and rejects a `universe` block without a resolvable
+* `universeId`.
+*/
+interface UniverseEntry {
+  /** Whether console players can join; omit or set `undefined` to leave unmanaged. */
+  consoleEnabled?: boolean | undefined;
+  /** Whether desktop players can join; omit or set `undefined` to leave unmanaged. */
+  desktopEnabled?: boolean | undefined;
+  /**
+  * Discord social link; omit to leave the server value untouched, set to
+  * `undefined` to clear it, or set to a `SocialLink` to update it.
+  */
+  discordSocialLink?: SocialLink | undefined;
+  /**
+  * Display name for the universe. Because Roblox derives this from
+  * the root place's name, the driver routes the update through
+  * `PlacesClient.update`; omit or set `undefined` to leave unmanaged.
+  */
+  displayName?: string | undefined;
+  /**
+  * Facebook social link; omit to leave the server value untouched, set to
+  * `undefined` to clear it, or set to a `SocialLink` to update it.
+  */
+  facebookSocialLink?: SocialLink | undefined;
+  /**
+  * Guilded social link; omit to leave the server value untouched, set to
+  * `undefined` to clear it, or set to a `SocialLink` to update it.
+  */
+  guildedSocialLink?: SocialLink | undefined;
+  /**
+  * Locale-keyed experience-icon paths. The map shape teaches that icons
+  * are per-locale; v1 only accepts the `"en-us"` key. Omit to leave the
+  * server icon unmanaged; remove a previously declared locale to delete
+  * its icon on the next deploy.
+  */
+  icon?: Record<"en-us", string>;
+  /** Whether mobile players can join; omit or set `undefined` to leave unmanaged. */
+  mobileEnabled?: boolean | undefined;
+  /**
+  * Private-server price in Robux. Declare as `undefined` to disable
+  * private servers (cancels active subscriptions); omit to leave the
+  * server value untouched.
+  */
+  privateServerPriceRobux?: number | undefined;
+  /**
+  * Roblox Group social link; omit to leave the server value untouched, set
+  * to `undefined` to clear it, or set to a `SocialLink` to update it.
+  */
+  robloxGroupSocialLink?: SocialLink | undefined;
+  /** Whether tablet players can join; omit or set `undefined` to leave unmanaged. */
+  tabletEnabled?: boolean | undefined;
+  /**
+  * Twitch social link; omit to leave the server value untouched, set to
+  * `undefined` to clear it, or set to a `SocialLink` to update it.
+  */
+  twitchSocialLink?: SocialLink | undefined;
+  /**
+  * Twitter social link; omit to leave the server value untouched, set to
+  * `undefined` to clear it, or set to a `SocialLink` to update it.
+  */
+  twitterSocialLink?: SocialLink | undefined;
+  /**
+  * Existing Roblox universe ID. Optional in this entry shape because
+  * authors may declare it here (root-authoritative, single universe) or
+  * on each `environments[name].universe` overlay (per-environment
+  * universes), but never both.
+  */
+  universeId?: string | undefined;
+  /** Whether voice chat is enabled; omit or set `undefined` to leave unmanaged. */
+  voiceChatEnabled?: boolean | undefined;
+  /** Whether VR players can join; omit or set `undefined` to leave unmanaged. */
+  vrEnabled?: boolean | undefined;
+  /**
+  * YouTube social link; omit to leave the server value untouched, set to
+  * `undefined` to clear it, or set to a `SocialLink` to update it.
+  */
+  youtubeSocialLink?: SocialLink | undefined;
+}
+/**
+* State configuration for the GitHub Gist backend. Holds the public gist
+* ID; the GitHub token is read from `GITHUB_TOKEN` only when the library
+* default-constructs the adapter.
+*/
+interface GistStateConfig {
+  /** Discriminator selecting the gist adapter. */
+  readonly backend: "gist";
+  /** ID of an existing GitHub Gist that holds this project's state files. */
+  readonly gistId: string;
+}
+/**
+* Tagged union describing where Bedrock persists its state. The `backend`
+* tag is `"gist" | (string & {})` so unknown names autocomplete the
+* builtins while permitting custom values for plugin scenarios. The
+* dispatch path inside `deploy()` rejects unknown names with a typed
+* `unsupportedBackend` error.
+*/
+type StateConfig = GistStateConfig | {
+  readonly backend: string & {};
+};
+/**
+* Body of a single entry under `environments`. Per-environment overrides
+* narrow root-level settings for that environment without redefining
+* unrelated fields. Resource overlays (`passes`, `places`, `universe`)
+* derive their field shapes from the matching root entry types so adding
+* a field to a base entry surfaces on the overlay automatically.
+*
+* `placeId` stays required when the matching `places` overlay is present
+* because each environment targets its own Roblox place. `universeId` is
+* optional on the `universe` overlay because authors may declare it
+* either at the root (root-authoritative) or per environment, but never
+* both: the schema enforces this XOR at validation time, attributing the
+* failure to the offending field's path.
+*/
+interface EnvironmentEntry {
+  /**
+  * Human-readable label fed to the project-level
+  * {@link DisplayNamePrefixConfig.format | displayNamePrefix.format}
+  * template. An environment without a label (or with an empty string)
+  * is implicitly excluded from prefixing even when the project enables
+  * it.
+  */
+  label?: string | undefined;
+  /**
+  * Per-environment game-pass overlay. Every field is optional; missing
+  * fields fall through to the matching root `passes` entry at merge time.
+  *
+  * Uses `Partial<GamePassEntry>` directly rather than `Overlay<T, K>`
+  * because game passes have no user-supplied identity key (Open Cloud
+  * mints the asset ID). The other overlay fields use `Overlay<T, K>`
+  * to keep their identity-bearing key required.
+  */
+  passes?: Record<string, Partial<GamePassEntry>>;
+  /**
+  * Per-environment places overlay. `placeId` is required on every
+  * declared entry; `filePath` is optional and falls through to the
+  * matching root `places` entry when omitted.
+  */
+  places?: Record<string, Overlay<ResolvedPlaceEntry, "placeId">>;
+  /**
+  * Per-environment developer-product overlay. Every field is optional;
+  * missing fields fall through to the matching root `products` entry at
+  * merge time. Mirrors the `passes` shape because developer products
+  * also have no user-supplied identity key (Open Cloud mints the
+  * `productId`).
+  */
+  products?: Record<string, Partial<DeveloperProductEntry>>;
+  /** Per-environment state override; takes precedence over root `state`. */
+  state?: StateConfig;
+  /**
+  * Per-environment universe overlay. Every field is optional, including
+  * `universeId`: the schema-level XOR rule requires `universeId` here if
+  * and only if the root `universe` block does not declare one. Other
+  * fields fall through to the root `universe` block when omitted.
+  */
+  universe?: Partial<UniverseEntry>;
+}
+/**
+* Per-kind entry registry. Each `ResourceKind` must have a matching entry
+* type or `ResourceEntryByKind[K]` is a compile error. Modelled as an
+* interface (not a type alias) so downstream resource kinds can declare
+* their entry type alongside the kind's other domain types without
+* touching this module.
+*
+* @example
+*
+* ```ts
+* import type { ResourceEntryByKind } from "@bedrock-rbx/core/config";
+*
+* const entry: ResourceEntryByKind["gamePass"] = {
+*     description: "Grants VIP perks.",
+*     icon: { "en-us": "assets/vip-icon.png" },
+*     name: "VIP Pass",
+*     price: 500,
+* };
+*
+* expect(entry.name).toBe("VIP Pass");
+* ```
+*/
+interface ResourceEntryByKind {
+  /** Authored entry body for a developer-product resource. */
+  developerProduct: DeveloperProductEntry;
+  /** Authored entry body for a game-pass resource. */
+  gamePass: GamePassEntry;
+  /** Post-merge entry body for a place resource (root + env overlay). */
+  place: ResolvedPlaceEntry;
+  /** Authored entry body for a universe resource. */
+  universe: UniverseEntry;
+}
+/**
+* Project-level prefixing policy for universe and place display names.
+* Each environment's `label` flows through `format` to render a prefix
+* that `selectEnvironment` prepends to every declared display name.
+*
+* Defaults: `enabled` is `true`; `format` is `"[{LABEL}] "`.
+*/
+interface DisplayNamePrefixConfig {
+  /**
+  * Whether the project applies environment-label prefixing. Treat
+  * `undefined` as enabled; set `false` to opt out across the project.
+  */
+  enabled?: boolean | undefined;
+  /**
+  * Template string applied to each environment's `label`. Placeholders:
+  *
+  * - `{label}`: label as written.
+  * - `{LABEL}`: upper-cased label.
+  * - `{Label}`: capitalized label (first character upper, rest as
+  *   written).
+  *
+  * Any other characters in the template flow through verbatim. The
+  * rendered string is prepended to each declared `displayName`.
+  */
+  format?: string | undefined;
+}
+/**
+* Per-environment universe overlay shape that prevents `universeId` from
+* being redeclared alongside a root-authoritative `universeId`.
+* Used by {@link ConfigRootUniverseId}: when the root universe block
+* declares `universeId`, no per-env overlay may redeclare it. Setting
+* `universeId` here produces a descriptive type error pointing at this
+* field rather than the opaque `never` message.
+*/
+type UniverseOverlayWithoutId = Partial<WithoutKey<UniverseEntry, "universeId">> & {
+  universeId?: "universeId is already declared on the root universe block; remove it from this environment overlay, or remove it from root and declare it on every environment overlay instead" & {
+    readonly errorBrand: never;
+  };
+};
+/**
+* Per-environment universe overlay shape that requires `universeId`.
+* Used by {@link ConfigEnvironmentUniverseId}: when the root universe
+* block does not declare `universeId`, every env that declares a
+* `universe` overlay must supply one of its own.
+*/
+type UniverseOverlayWithId = Partial<WithoutKey<UniverseEntry, "universeId">> & {
+  universeId: string;
+};
+/**
+* Variant of `Config` where the root `universe` block declares
+* `universeId`. Per-environment universe overlays may carry shared
+* fields (device flags, social links, display name, icon) but cannot
+* redeclare `universeId`; the schema rejects any env overlay that
+* does. The runtime `selectEnvironment` merges shared-field overlays
+* onto the root and inherits `universeId` from the root unchanged.
+*/
+type ConfigRootUniverseId = ConfigBase & {
+  /**
+  * Per-environment overrides keyed by environment name. Required and
+  * non-empty; environment names match `[A-Za-z0-9_-]{1,64}`. Each env
+  * entry's `universe` overlay forbids `universeId` because the root
+  * declares it.
+  */
+  environments: Record<string, WithoutKey<EnvironmentEntry, "universe"> & {
+    universe?: UniverseOverlayWithoutId;
+  }>;
+  /**
+  * Singleton universe block declaring the Roblox universe bedrock
+  * manages. `universeId` is required in this variant because no
+  * per-environment overlay may supply one.
+  */
+  universe?: UniverseEntry & {
+    universeId: string;
+  };
+};
+/**
+* Variant of `Config` where the root `universe` block omits
+* `universeId`. Every env that declares a `universe` overlay must
+* supply its own `universeId`; envs that omit the overlay deploy no
+* universe at all. The root may still carry shared fields (device
+* flags, social links, display name, icon) which `selectEnvironment`
+* merges onto each env's overlay at resolution time.
+*/
+type ConfigEnvironmentUniverseId = ConfigBase & {
+  /**
+  * Per-environment overrides keyed by environment name. Required and
+  * non-empty; environment names match `[A-Za-z0-9_-]{1,64}`. Every
+  * env that declares a `universe` overlay must include `universeId`
+  * because the root universe block does not provide one.
+  */
+  environments: Record<string, WithoutKey<EnvironmentEntry, "universe"> & {
+    universe?: UniverseOverlayWithId;
+  }>;
+  /**
+  * Singleton universe block declaring the Roblox universe bedrock
+  * manages. `universeId` is not permitted here in this variant because
+  * every environment supplies its own; setting it produces a descriptive
+  * type error rather than the opaque `never` message.
+  */
+  universe?: WithoutKey<UniverseEntry, "universeId"> & {
+    universeId?: "universeId is already declared per environment; remove it from the root universe block, or remove it from every environment overlay and declare it here instead" & {
+      readonly errorBrand: never;
+    };
+  };
+};
+/**
+* Validated project config as accepted by `loadConfig`. Plain mutable so
+* users can adjust fields in a long-running script before deploying.
+*
+* Discriminated union over the location of `universeId`: it lives at the
+* root universe block ({@link ConfigRootUniverseId}) or on every
+* environment universe overlay ({@link ConfigEnvironmentUniverseId}), but never
+* both. The TypeScript types reject the both-set case at compile time,
+* and the arktype runtime narrow rejects every offending field path at
+* `validateConfig` time. State must be configured at the root or under
+* every entry of `environments`; `resolveStateConfig` surfaces the
+* missing case at the deploy boundary as `stateNotConfigured`.
+*
+* @example
+*
+* ```ts
+* import type { Config } from "@bedrock-rbx/core/config";
+*
+* const config: Config = {
+*     environments: { production: {} },
+*     state: { backend: "gist", gistId: "abc123def456" },
+*     passes: {
+*         "vip-pass": {
+*             description: "Grants VIP perks.",
+*             icon: { "en-us": "assets/vip-icon.png" },
+*             name: "VIP Pass",
+*             price: 500,
+*         },
+*     },
+* };
+*
+* expect(config.passes!["vip-pass"]!.name).toBe("VIP Pass");
+* ```
+*/
+type Config = ConfigEnvironmentUniverseId | ConfigRootUniverseId;
+/**
+* Body of the singleton `universe` block after `selectEnvironment` has
+* merged a per-environment overlay onto the root. Identical to
+* {@link UniverseEntry} except `universeId` is required: the schema-level
+* XOR rule ensures every projected universe carries a resolved
+* `universeId`. Resource drivers consume this shape rather than
+* `UniverseEntry` so the post-merge invariant is visible in the type
+* system.
+*/
+interface ResolvedUniverseEntry extends Pick<UniverseEntry, Exclude<keyof UniverseEntry, "universeId">> {
+  /** Existing Roblox universe ID, resolved from the root or per-environment overlay. */
+  universeId: string;
+}
+/**
+* Project config after `selectEnvironment` has merged a single
+* environment's overlays onto the root. The shape mirrors `Config`
+* except `places` carries `ResolvedPlaceEntry` (both `filePath` and
+* `placeId`), since the resolver fails before this point if an entry is
+* missing its environment-supplied `placeId`. Downstream consumers
+* (`flattenConfig`, `buildDefaultRegistry`, the deploy pipeline) accept
+* this shape rather than `Config` so the post-merge invariant is visible
+* in the type system.
+*
+* @example
+*
+* ```ts
+* import { selectEnvironment, type ResolvedConfig } from "@bedrock-rbx/core";
+* import type { Config } from "@bedrock-rbx/core/config";
+*
+* const config: Config = {
+*     environments: {
+*         production: { places: { "start-place": { placeId: "4711" } } },
+*     },
+*     places: { "start-place": { filePath: "places/start.rbxl" } },
+*     state: { backend: "gist", gistId: "abc" },
+* };
+*
+* const result = selectEnvironment(config, "production");
+* expect(result.success).toBeTrue();
+* if (result.success) {
+*     const resolved: ResolvedConfig = result.data;
+*     expect(resolved.places?.["start-place"]?.placeId).toBe("4711");
+* }
+* ```
+*/
+interface ResolvedConfig extends Pick<ConfigBase, Exclude<keyof ConfigBase, "places">> {
+  /**
+  * Per-environment overrides preserved from the source `Config`.
+  * Carried for downstream context; `selectEnvironment` does not read
+  * other environments after resolving the requested one.
+  */
+  environments: Record<string, EnvironmentEntry>;
+  /** Keyed-map collection of resolved place entries; both `filePath` and `placeId` are present. */
+  places?: Record<string, ResolvedPlaceEntry>;
+  /**
+  * Singleton universe block after `selectEnvironment` has resolved the
+  * XOR between root and per-environment `universeId`. The schema narrow
+  * rejects any config that would leave `universeId` unresolved, so the
+  * post-merge invariant promotes `universeId` from optional to required.
+  */
+  universe?: ResolvedUniverseEntry;
+}
+/**
+* Overlay shape used by per-environment entries: every field of `T`
+* becomes optional, except `RequiredKey`, which stays required so the
+* overlay still re-asserts the identity-bearing field of its target
+* resource.
+*
+* @template T - Base entry type whose field shapes the overlay derives from.
+* @template RequiredKey - Identity-bearing key on `T` that the overlay must
+* still declare (for example `"placeId"` or `"universeId"`).
+*/
+type Overlay<T, RequiredKey extends keyof T> = SetRequired<Partial<T>, RequiredKey>;
+/**
+* Helper that produces a shallow `Omit<T, K>` without using TypeScript's
+* built-in `Omit` (deprecated under the project's lint rules because of
+* its lossy interaction with mapped types).
+*
+* @template T - Source type to project keys away from.
+* @template Key - Key (or union of keys) on `T` to remove.
+*/
+type WithoutKey<T, Key extends keyof T> = Pick<T, Exclude<keyof T, Key>>;
+/**
+* Fields shared by every {@link Config} variant. The discriminated
+* `Config` union narrows `universe` and `environments` to enforce the
+* `universeId` XOR rule between the root and per-environment overlays;
+* everything else lives here.
+*/
+interface ConfigBase {
+  /**
+  * Project-level prefixing of universe and place display names with the
+  * environment label. Default behaviour (when omitted) is enabled with a
+  * `"[{LABEL}] "` template; set `enabled: false` to opt out, or set
+  * `format` to a custom template.
+  */
+  displayNamePrefix?: DisplayNamePrefixConfig;
+  /** Reserved at the root for c12's config layering / overlay work. */
+  extends?: unknown;
+  /** Keyed-map collection of game-pass entries by user-supplied ResourceKey. */
+  passes?: Record<string, GamePassEntry>;
+  /** Keyed-map collection of place entries by user-supplied ResourceKey. */
+  places?: Record<string, PlaceEntry>;
+  /** Keyed-map collection of developer-product entries by user-supplied ResourceKey. */
+  products?: Record<string, DeveloperProductEntry>;
+  /** Where Bedrock persists state for this project; required at deploy time. */
+  state?: StateConfig;
+}
+/**
+* Narrow a `StateConfig` to the `GistStateConfig` arm. The `(string & {})`
+* autocomplete idiom prevents TypeScript from narrowing on
+* `backend === "gist"` alone, so dispatch sites use this guard to
+* preserve the `gistId` field shape.
+*
+* @example
+*
+* ```ts
+* import { isGistStateConfig } from "@bedrock-rbx/core";
+* import type { StateConfig } from "@bedrock-rbx/core/config";
+*
+* const config: StateConfig = { backend: "gist", gistId: "abc" };
+*
+* expect(isGistStateConfig(config)).toBeTrue();
+* if (isGistStateConfig(config)) {
+*     expect(config.gistId).toBe("abc");
+* }
+* ```
+*
+* @param config - Resolved state config to inspect.
+* @returns `true` when `config.backend === "gist"`; otherwise `false`.
+*/
+declare function isGistStateConfig(config: StateConfig): config is GistStateConfig;
+/**
+* Validate a parsed config value against the runtime schema. Returns the
+* validated `Config` on success or a `validationFailed` `ConfigError` with
+* one issue per problem, each attributed to a field path. `sourceFile`
+* appears in the error so callers can point a human at the offending file.
+*
+* @param input - Parsed value from a config source (object tree from a
+* config loader, or a hand-built literal). Shape is checked, not assumed.
+* @param sourceFile - Path or identifier of the source file, used in the
+* `validationFailed` error.
+* @returns `Ok` with the validated `Config`, or `Err` with a
+* `validationFailed` error carrying each issue's field path.
+* @example
+*
+* ```ts
+* import { validateConfig } from "@bedrock-rbx/core";
+*
+* const ok = validateConfig(
+*     {
+*         environments: { production: {} },
+*         passes: {
+*             "vip-pass": {
+*                 description: "VIP perks.",
+*                 icon: { "en-us": "assets/vip.png" },
+*                 name: "VIP Pass",
+*                 price: 500,
+*             },
+*         },
+*     },
+*     "bedrock.config.ts",
+* );
+* expect(ok.success).toBeTrue();
+*
+* const err = validateConfig(
+*     { environments: { production: {} }, passes: { "vip-pass": { name: "VIP" } } },
+*     "bedrock.config.ts",
+* );
+* expect(err.success).toBeFalse();
+* if (!err.success) {
+*     expect(err.err.kind).toBe("validationFailed");
+* }
+* ```
+*/
+declare function validateConfig(input: unknown, sourceFile: string): Result<Config, ConfigError>;
+//#endregion
+//#region src/shell/define-config.d.ts
+/**
+* Context object passed to a config-function input. Intentionally empty so
+* future ADRs can add fields without breaking existing user configs.
+*/
+interface ConfigContext {}
+/**
+* Input accepted by `defineConfig`: a plain `Config` object, or a
+* (sync or async) function that returns one given a `ConfigContext`.
+*/
+type ConfigInput = ((ctx: ConfigContext) => Config | Promise<Config>) | Config;
+/**
+* Identity helper that gives TypeScript users full inference over a config
+* declared in a `bedrock.config.ts` file. Returns its argument unchanged so
+* `defineConfig(...)` is free at runtime.
+*
+* Accepts a plain `Config` object or a function that produces one. The
+* function form lets users compute config values from external data at load
+* time; `loadConfig` awaits the result on call.
+*
+* @template T - Narrow `ConfigInput` subtype preserved across the call so
+* downstream inference does not widen to `Config | (ctx) => Config`.
+* @param config - Either a `Config` literal or a function returning one.
+* @returns The same argument, typed as the narrower `T` so downstream
+* inference does not widen.
+* @example
+*
+* ```ts
+* import { defineConfig } from "@bedrock-rbx/core/config";
+*
+* const config = defineConfig({
+*     environments: { production: {} },
+*     passes: {
+*         "vip-pass": {
+*             description: "Grants VIP perks.",
+*             icon: { "en-us": "assets/vip-icon.png" },
+*             name: "VIP Pass",
+*             price: 500,
+*         },
+*     },
+* });
+*
+* expect(config.passes!["vip-pass"]!.name).toBe("VIP Pass");
+* ```
+*/
+declare function defineConfig<T extends ConfigInput>(config: T): T;
+//#endregion
+export { ConfigError as C, validateConfig as S, StateConfig as _, ConfigEnvironmentUniverseId as a, UniverseOverlayWithoutId as b, DisplayNamePrefixConfig as c, GistStateConfig as d, PlaceEntry as f, ResourceEntryByKind as g, ResolvedUniverseEntry as h, Config as i, EnvironmentEntry as l, ResolvedPlaceEntry as m, ConfigInput as n, ConfigRootUniverseId as o, ResolvedConfig as p, defineConfig as r, DeveloperProductEntry as s, ConfigContext as t, GamePassEntry as u, UniverseEntry as v, ConfigValidationIssue as w, isGistStateConfig as x, UniverseOverlayWithId as y };
+//# sourceMappingURL=define-config-D-LAhfSJ.d.mts.map