buildspec

Documentation

Overview

Package buildspec is the KIDS build-spec schema + validating loader (VSL T0a.1, CQ9): the declarative, diffable git source of a KIDS BUILD (#9.6), kids/<pkg>.build.json. It is the human-readable form of a package definition — component list, Required Builds, the environment-check routine, and the ICR list — that `v pkg build` consumes to produce a transport global / .KID. See msl-vsl-coordination-implementation-plan.md §7.2.

Index

• Constants
• Variables
• type Components
• type FieldSpec
• type FileComp
• type FileDataSpec
• type FileRecordSpec
• type HL7AppComp
• type HLOAppComp
• type HLOMsgTypComp
• type HelpFrameComp
• type ICR
• type KeyComp
• type ListTemplateComp
• type LogicalLinkComp
• type MailGroupComp
• type OptionComp
• type OptionMenuItemComp
• type ParamDef
• type ParamEntity
• type ProtocolComp
• type ProtocolItemComp
• type RPCComp
• type RPCParamComp
• type RequiredBuild
• type SetCodeSpec
• type Spec
  • func Load(path string) (*Spec, error)
  • func Parse(data []byte) (*Spec, error)
  • func (s *Spec) InstallName() string
  • func (s *Spec) Validate() error

Constants

const (
	ActionWarn         = "WARNING ONLY"                 // warn, continue
	ActionLeaveGlobal  = "DON'T INSTALL, LEAVE GLOBAL"  // block unless prerequisite present; keep its global
	ActionRemoveGlobal = "DON'T INSTALL, REMOVE GLOBAL" // block unless prerequisite present; remove its global
)

Required-build install actions (KIDS BUILD #9.6 REQUIRED BUILD #11 multiple; architecture §3.1).

const (
	LocalFileMin = 999000
	LocalFileMax = 999999
)

Local/test FileMan file-number range (VA-reserved 999000-999999). A v-pkg DD-install ships only throwaway files in this band — never a national file.

const (
	RoutineNameMaxStd  = 8
	RoutineNameMaxLong = 31
)

Routine-name length caps. RoutineNameMaxStd is the legacy SAC/DSM-era convention (a 2-4 char namespace + remainder, 8 total). RoutineNameMaxLong is the modern M engine limit honored by YottaDB and IRIS (31 significant characters) — used when a spec sets allowLongNames. KIDS itself (transport global, string-subscript keyed) and XINDEX impose no name-length limit; the 8 is a convention, the 31 is the real engine bound.

Variables

var DataActionCode = map[string]string{
	"add only if new": "a",
	"merge":           "m",
	"overwrite":       "o",
	"replace":         "r",
}

DataActionCode maps a FileDataSpec action name to its FileMan #9.64,222.8 SITE'S DATA send-options letter (piece 8): "a"=ADD ONLY IF NEW FILE, "m"=MERGE, "o"=OVERWRITE, "r"=REPLACE — the letters EN^DIFROMS4 reads at install.

var MailGroupTypeCode = map[string]string{
	"public":  "PU",
	"private": "PR",
}

MailGroupTypeCode maps a human mail-group-type name to its #3.8 field 4 (TYPE) set-of-codes value. Grounded in the live ^DD(3.8,4) set string. National constants.

var OptionTypeCode = map[string]string{
	"action":          "A",
	"edit":            "E",
	"inquire":         "I",
	"menu":            "M",
	"print":           "P",
	"run routine":     "R",
	"protocol":        "O",
	"protocol menu":   "Q",
	"extended action": "X",
	"server":          "S",
}

OptionTypeCode maps a human option-type name to its #19 field 4 (TYPE) set-of-codes value. Grounded in the live ^DD(19,4) set string (Kernel Menu Manager). These codes are national constants — portable across YDB and IRIS.

var ParamDataTypeCode = map[string]string{
	"free text":       "F",
	"numeric":         "N",
	"yes/no":          "Y",
	"set of codes":    "S",
	"date/time":       "D",
	"pointer":         "P",
	"word processing": "W",
}

ParamDataTypeCode maps a human value-data-type name to the #8989.51 field 1.1 (VALUE DATA TYPE) set-of-codes value. Free text is the default; the rest are accepted for completeness.

var ParamEntityIEN = map[string]string{
	"DEV": "3.5",
	"DIV": "4",
	"SYS": "4.2",
	"PKG": "9.4",
	"LOC": "44",
	"SRV": "49",
	"USR": "200",
	"CLS": "8930",
}

ParamEntityIEN maps a parameter-entity abbreviation to its #8989.518 (PARAMETER ENTITY) IEN. #8989.518 is DINUM'd to the pointed-to file number, so these IENs are national constants — portable across YDB and IRIS VistA.

var ProtocolTypeCode = map[string]string{
	"action":           "A",
	"menu":             "M",
	"protocol":         "O",
	"protocol menu":    "Q",
	"limited protocol": "L",
	"extended action":  "X",
	"dialog":           "D",
	"term":             "T",
	"event driver":     "E",
	"subscriber":       "S",
}

ProtocolTypeCode maps a human protocol-type name to its #101 field 4 (TYPE) set-of-codes value. Grounded in the live ^DD(101,4) set string (these codes are #101's OWN — they differ from #19 OPTION's). National constants.

var RPCParamTypeCode = map[string]string{
	"literal":         "1",
	"list":            "2",
	"word processing": "3",
	"reference":       "4",
}

RPCParamTypeCode maps a human RPC-parameter-type name to its #8994.02 field .02 (PARAMETER TYPE) set-of-codes value. National constants.

var RPCReturnTypeCode = map[string]string{
	"single value":    "1",
	"array":           "2",
	"word processing": "3",
	"global array":    "4",
	"global instance": "5",
}

RPCReturnTypeCode maps a human return-value-type name to its #8994 field .04 (RETURN VALUE TYPE) set-of-codes value. National constants.

var RequiredBuildActionCode = map[string]int{
	ActionWarn:         0,
	ActionRemoveGlobal: 1,
	ActionLeaveGlobal:  2,
}

RequiredBuildActionCode maps a Required-Build action to its #9.611 ACTION set-of-codes value (0 = warn, 1 = don't install/remove global, 2 = don't install/leave global).

Types

type Components

type Components struct {
	Routines             []string           `json:"routines,omitempty"`
	Files                []FileComp         `json:"files,omitempty"`
	Options              []OptionComp       `json:"options,omitempty"`              // #19 OPTION KRN components (B.1)
	Keys                 []KeyComp          `json:"keys,omitempty"`                 // #19.1 SECURITY KEY KRN components (B.1)
	Parameters           []string           `json:"parameters,omitempty"`           // XPAR parameter names (reference only)
	ParameterDefinitions []ParamDef         `json:"parameterDefinitions,omitempty"` // XPAR #8989.51 PARAMETER DEFINITION components (shipped as data)
	Protocols            []ProtocolComp     `json:"protocols,omitempty"`            // #101 PROTOCOL KRN components (B.1)
	Templates            []string           `json:"templates,omitempty"`
	RPCs                 []RPCComp          `json:"rpcs,omitempty"`            // #8994 REMOTE PROCEDURE KRN components (B.1)
	MailGroups           []MailGroupComp    `json:"mailGroups,omitempty"`      // #3.8 MAIL GROUP KRN components (B.1)
	ListTemplates        []ListTemplateComp `json:"listTemplates,omitempty"`   // #409.61 LIST TEMPLATE KRN components (B.1)
	HelpFrames           []HelpFrameComp    `json:"helpFrames,omitempty"`      // #9.2 HELP FRAME KRN components (B.1)
	HL7Applications      []HL7AppComp       `json:"hl7Applications,omitempty"` // #771 HL7 APPLICATION PARAMETER KRN components (B.1)
	HLOApplications      []HLOAppComp       `json:"hloApplications,omitempty"` // #779.2 HLO APPLICATION REGISTRY KRN components (B.1)
	LogicalLinks         []LogicalLinkComp  `json:"logicalLinks,omitempty"`    // #870 HL LOGICAL LINK KRN components (B.1)
}

Components is the BUILD component list (#9.6). Each slice is omitempty so a spec lists only what it ships.

type FieldSpec

type FieldSpec struct {
	Number   float64 `json:"number"`             // field number (> .01)
	Label    string  `json:"label"`              // field LABEL (uppercase)
	Type     string  `json:"type"`               // free text | numeric | date | set of codes | pointer
	Node     int     `json:"node,omitempty"`     // storage node (default 0)
	Piece    int     `json:"piece"`              // storage piece (≥1; (0;1) is reserved for the .01)
	Required bool    `json:"required,omitempty"` // R attribute
	Help     string  `json:"help,omitempty"`     // reader help prompt

	MaxLen int `json:"maxLen,omitempty"` // free text: max length (0 → default 30)

	Width    int      `json:"width,omitempty"`    // numeric: print width (NJ<width>,<decimals>)
	Decimals int      `json:"decimals,omitempty"` // numeric: decimal places
	Min      *float64 `json:"min,omitempty"`      // numeric: lower bound
	Max      *float64 `json:"max,omitempty"`      // numeric: upper bound

	Time bool `json:"time,omitempty"` // date: allow a time component

	Codes []SetCodeSpec `json:"codes,omitempty"` // set of codes: value list

	PointTo   float64 `json:"pointTo,omitempty"`   // pointer: pointed-to file number
	PointRoot string  `json:"pointRoot,omitempty"` // pointer: pointed-to global root
}

FieldSpec is one FileMan field beyond the implicit free-text .01 NAME, declared in a FILE component. Type selects the DD grammar; Node/Piece are the storage location ("<Node>;<Piece>"). Type-specific knobs (Width/Decimals/Min/Max for numeric, Codes for set-of-codes, PointTo/PointRoot for pointer, MaxLen for free text, Time for date) are validated against the declared Type.

type FileComp

type FileComp struct {
	Number     float64       `json:"number"`
	Name       string        `json:"name,omitempty"`
	GlobalRoot string        `json:"globalRoot,omitempty"` // data global, e.g. "^DIZ(999000,"; default derived from Number
	Fields     []FieldSpec   `json:"fields,omitempty"`     // fields beyond the implicit .01 NAME (empty = single-.01 file)
	Data       *FileDataSpec `json:"data,omitempty"`       // optional data records shipped with the file
}

FileComp is a FileMan FILE component shipped as a KIDS data-dictionary export. For VSL M3.T1 the supported shape is a brand-new throwaway file with a single free-text .01 NAME field (the minimal transform-invariant DD); Number is a local/test file number (999000-999999) and GlobalRoot is its data global (defaulting to ^DIZ(<file>,).

type FileDataSpec

type FileDataSpec struct {
	Action  string           `json:"action"` // add only if new | merge | overwrite | replace
	Records []FileRecordSpec `json:"records"`
}

FileDataSpec declares data records shipped with a file plus the install action that governs how they merge with any site data. Action is a human name mapped to the #9.64,222.8 SITE'S DATA send-options letter via DataActionCode.

type FileRecordSpec

type FileRecordSpec struct {
	IEN    int64             `json:"ien"`
	Values map[string]string `json:"values"`
}

FileRecordSpec is one data record: its IEN and a map of field number (as a string, ".01" for the NAME) to the record's internal value for that field.

type HL7AppComp

type HL7AppComp struct {
	Name        string `json:"name"`                  // #771 .01 NAME (uppercase, spaces/underscores)
	Facility    string `json:"facility,omitempty"`    // #771 field 3 FACILITY NAME
	CountryCode string `json:"countryCode,omitempty"` // #771 field 7 COUNTRY CODE (default "USA")
}

HL7AppComp is a #771 HL7 APPLICATION PARAMETER shipped as a KIDS KRN component (B.1) — the registration of an application that sends/receives HL7 messages. The build files the entry ACTIVE (a shipped registration is always active); CountryCode defaults to "USA". HL7 application names allow spaces AND underscores (e.g. "VISTA_VTS"), unlike the space-only OPTION/RPC names. (The HLO registry #779.2 and logical link #870 are follow-ups.)

type HLOAppComp

type HLOAppComp struct {
	Name         string          `json:"name"`                   // #779.2 .01 APPLICATION NAME (3..60 chars)
	MessageTypes []HLOMsgTypComp `json:"messageTypes,omitempty"` // #779.21 MESSAGE TYPE ACTIONS
}

HLOAppComp is a #779.2 HLO APPLICATION REGISTRY shipped as a KIDS KRN component (B.1) — the HL7-Optimized counterpart to #771. It registers an application and maps the HL7 message types it handles (the messageTypes multiple) to action routines. The emitter ships each message-type entry with its computed cross-references.

type HLOMsgTypComp

type HLOMsgTypComp struct {
	MessageType   string `json:"messageType"`             // #779.21 .01 HL7 MESSAGE TYPE
	Event         string `json:"event"`                   // #779.21 .02 HL7 EVENT
	ActionTag     string `json:"actionTag,omitempty"`     // #779.21 .04 ACTION TAG
	ActionRoutine string `json:"actionRoutine,omitempty"` // #779.21 .05 ACTION ROUTINE
	Version       string `json:"version,omitempty"`       // #779.21 .06 HL7 VERSION
}

HLOMsgTypComp is one MESSAGE TYPE ACTIONS entry (#779.21) of an HLO application: the HL7 message type/event it handles and the action routine that processes it.

type HelpFrameComp

type HelpFrameComp struct {
	Name   string   `json:"name"`             // #9.2 .01 NAME (3–30 chars, uppercase, hyphens/spaces)
	Header string   `json:"header,omitempty"` // #9.2 field 1 HEADER — one-line summary
	Text   []string `json:"text,omitempty"`   // #9.2 field 2 TEXT — the help body, one string per line
}

HelpFrameComp is a #9.2 HELP FRAME shipped as a KIDS KRN component (B.1). The build files the frame: a name, a one-line HEADER summary, and the TEXT body (a word-processing field — the help content). HELP FRAME names allow spaces AND hyphens (e.g. "YS-PHY-EXAM-NORM"), unlike the space-only OPTION/RPC names.

type ICR

type ICR struct {
	Number    int    `json:"number"`
	Name      string `json:"name,omitempty"`
	Custodian string `json:"custodian,omitempty"`
}

ICR is a DBIA/Integration Control Registration the package depends on.

type KeyComp

type KeyComp struct {
	Name        string   `json:"name"`                  // #19.1 .01 NAME (uppercase, e.g. "ZZKEY MANAGER")
	Description []string `json:"description,omitempty"` // #19.1 DESCRIPTION word-processing lines (optional)
}

KeyComp is a #19.1 SECURITY KEY shipped as a KIDS KRN component (B.1). A key is a named token holders are granted; the build files the key by name (its optional word-processing DESCRIPTION is a follow-up).

type ListTemplateComp

type ListTemplateComp struct {
	Name         string `json:"name"`                   // #409.61 .01 NAME (uppercase, e.g. "ZZLM PATIENTS")
	ScreenTitle  string `json:"screenTitle,omitempty"`  // .11 SCREEN TITLE
	ProtocolMenu string `json:"protocolMenu,omitempty"` // .1 PROTOCOL MENU — #101 action-menu name
	RightMargin  int    `json:"rightMargin,omitempty"`  // .04 RIGHT MARGIN (default 80)
	TopMargin    int    `json:"topMargin,omitempty"`    // .05 TOP MARGIN (default 3)
	BottomMargin int    `json:"bottomMargin,omitempty"` // .06 BOTTOM MARGIN (default 20)
	HeaderCode   string `json:"headerCode,omitempty"`   // HEADER CODE (M code, node "HDR")
	EntryCode    string `json:"entryCode,omitempty"`    // ENTRY CODE (M code, node "INIT")
	ExitCode     string `json:"exitCode,omitempty"`     // EXIT CODE (M code, node "FNL")
	HelpCode     string `json:"helpCode,omitempty"`     // HELP CODE (M code, node "HLP")
	ArrayName    string `json:"arrayName,omitempty"`    // ARRAY NAME (display global ref, node "ARRAY")
}

ListTemplateComp is a #409.61 LIST TEMPLATE (List Manager screen) shipped as a KIDS KRN component (B.1). The build files the screen definition: a name, screen geometry (margins, defaulted), the action PROTOCOL MENU (a #101 pointer by name), the screen title, and the List Manager callback codes (header/init/exit/help M code + the display ARRAY global). All plain strings — no compiled structure.

type LogicalLinkComp

type LogicalLinkComp struct {
	Name        string   `json:"name"`                  // #870 .01 NODE (3..10 chars)
	LLPType     string   `json:"llpType,omitempty"`     // #870 field 2 LLP TYPE (default "TCP")
	Port        string   `json:"port,omitempty"`        // #870 400.02 TCP/IP PORT
	ServiceType string   `json:"serviceType,omitempty"` // #870 400.03 TCP/IP SERVICE TYPE (C/S/M, default "C")
	Description []string `json:"description,omitempty"` // #870 DESCRIPTION word-processing lines (optional)
}

LogicalLinkComp is a #870 HL LOGICAL LINK shipped as a KIDS KRN component (B.1) — an HL7 communication endpoint. LLPType defaults to "TCP" (shipped as the external #869.1 value, resolved to its IEN at install). When Port (and/or ServiceType) is present the build also files the 400-node; ServiceType defaults to "C" (CLIENT/SENDER). A skeleton link with no TCP params is valid.

There is intentionally NO DNS domain / IP address field: the #870 install does not transport the network endpoint (it is site-specific config the install drops — see kids.LogicalLink). v-pkg ships the link definition; the site configures the endpoint. (The DESCRIPTION word-processing field is a follow-up.)

type MailGroupComp

type MailGroupComp struct {
	Name                string   `json:"name"`                          // #3.8 .01 NAME (uppercase, e.g. "ZZMG ALERTS")
	Type                string   `json:"type,omitempty"`                // mail-group type: public (default) | private
	AllowSelfEnrollment bool     `json:"allowSelfEnrollment,omitempty"` // #3.8 field 7 ALLOW SELF ENROLLMENT?
	Description         []string `json:"description,omitempty"`         // #3.8 DESCRIPTION word-processing lines (optional)
}

MailGroupComp is a #3.8 MAIL GROUP shipped as a KIDS KRN component (B.1). Type is a human name resolved to the #3.8 field 4 (TYPE) set-of-codes value by MailGroupTypeCode (default "public"). The build files the group definition only — KIDS ships mail groups MEMBER-less (the #200-pointer member list is site-local), and the word-processing DESCRIPTION is deferred (its header carries a volatile last-edited date that would defeat the deterministic-build invariant).

type OptionComp

type OptionComp struct {
	Name        string               `json:"name"`                  // #19 .01 NAME (uppercase, e.g. "ZZOPT RUN ROUTINE")
	MenuText    string               `json:"menuText,omitempty"`    // #19 field 1 MENU TEXT
	Type        string               `json:"type"`                  // option type: menu | run routine | action | ...
	Routine     string               `json:"routine,omitempty"`     // #19 field 25 ROUTINE entryref (required for "run routine")
	EntryAction string               `json:"entryAction,omitempty"` // #19 field 20 ENTRY ACTION (M code)
	ExitAction  string               `json:"exitAction,omitempty"`  // #19 field 15 EXIT ACTION (M code)
	MenuItems   []OptionMenuItemComp `json:"menuItems,omitempty"`   // #19.01 MENU multiple — child options of a menu
}

OptionComp is a #19 OPTION shipped as a KIDS KRN component (B.1). The build files the option definition (never a value); Type is a human option-type name resolved to its #19 field 4 (TYPE) set-of-codes value by OptionTypeCode. A run-routine option requires Routine; an action option typically sets EntryAction.

type OptionMenuItemComp

type OptionMenuItemComp struct {
	Name         string `json:"name"`                   // child OPTION .01 NAME (#19 pointer target)
	Synonym      string `json:"synonym,omitempty"`      // #19.01 .02 SYNONYM
	DisplayOrder int    `json:"displayOrder,omitempty"` // #19.01 .03 DISPLAY ORDER (default = position)
}

OptionMenuItemComp is one MENU entry of a menu OPTION (#19.01): the NAME of the child option to attach, an optional synonym, and its display order. The install re-points the child by name (KIDS "^" resolver node).

type ParamDef

type ParamDef struct {
	Name        string        `json:"name"`                  // #8989.51 .01 NAME (uppercase, e.g. "VSL GREETING")
	DisplayText string        `json:"displayText,omitempty"` // #8989.51 .02 DISPLAY TEXT
	DataType    string        `json:"dataType,omitempty"`    // value data type; default "free text"
	Entities    []ParamEntity `json:"entities,omitempty"`    // ALLOWABLE ENTITIES (#8989.513) — where the param may be set
}

ParamDef is an XPAR PARAMETER DEFINITION (#8989.51) shipped as a KIDS KRN component — the build creates the definition (not a value) at install time. DataType/Entity are human names resolved to their #8989.51 codes / #8989.518 IENs by ParamDataTypeCode / ParamEntityIEN.

type ParamEntity

type ParamEntity struct {
	Entity     string `json:"entity"`               // entity abbreviation: SYS, USR, PKG, …
	Precedence int    `json:"precedence,omitempty"` // #8989.513 .01 PRECEDENCE; default 1
}

ParamEntity is one ALLOWABLE ENTITIES row of a ParamDef: which entity the parameter may be set at, and its precedence.

type ProtocolComp

type ProtocolComp struct {
	Name        string             `json:"name"`                  // #101 .01 NAME (uppercase, e.g. "ZZPROTO ACTION")
	ItemText    string             `json:"itemText,omitempty"`    // #101 field 1 ITEM TEXT
	Type        string             `json:"type"`                  // protocol type: action | extended action | menu | event driver | ...
	EntryAction string             `json:"entryAction,omitempty"` // #101 field 20 ENTRY ACTION (M code)
	ExitAction  string             `json:"exitAction,omitempty"`  // #101 field 15 EXIT ACTION (M code)
	Items       []ProtocolItemComp `json:"items,omitempty"`       // #101.01 ITEM multiple — child protocols of a menu
}

ProtocolComp is a #101 PROTOCOL shipped as a KIDS KRN component (B.1). Type is a human option-type name resolved to its #101 field 4 (TYPE) set-of-codes value by ProtocolTypeCode. The build files a base protocol (the #101.01 ITEM multiple + extended menu-actions are a follow-up).

type ProtocolItemComp

type ProtocolItemComp struct {
	Name     string `json:"name"`               // child PROTOCOL .01 NAME (#101 pointer target)
	Sequence int    `json:"sequence,omitempty"` // #101.01 .03 SEQUENCE (default = position)
}

ProtocolItemComp is one ITEM of a menu PROTOCOL (#101.01): the NAME of the child protocol to attach and its display sequence. The install re-points the child by name (KIDS "^" resolver node), so cross-build references work.

type RPCComp

type RPCComp struct {
	Name            string         `json:"name"`                      // #8994 .01 NAME (uppercase, e.g. "ZZRPC ECHO")
	Tag             string         `json:"tag,omitempty"`             // #8994 .02 TAG — the M entry tag
	Routine         string         `json:"routine"`                   // #8994 .03 ROUTINE — the M routine
	ReturnType      string         `json:"returnType,omitempty"`      // value type; default "single value"
	InputParameters []RPCParamComp `json:"inputParameters,omitempty"` // #8994.02 INPUT PARAMETER multiple
}

RPCComp is a #8994 REMOTE PROCEDURE shipped as a KIDS KRN component (B.1). The DD-required fields are Name (.01) + Routine (.03) + ReturnType (.04); Tag (.02) is functionally required for the RPC to run. ReturnType is a human name resolved to its #8994 field .04 set-of-codes value by RPCReturnTypeCode (default "single value").

type RPCParamComp

type RPCParamComp struct {
	Name        string   `json:"name"`                  // #8994.02 .01 INPUT PARAMETER
	Type        string   `json:"type,omitempty"`        // literal (default) | list | word processing | reference
	MaxLength   int      `json:"maxLength,omitempty"`   // #8994.02 .03 MAXIMUM DATA LENGTH
	Required    bool     `json:"required,omitempty"`    // #8994.02 .04 REQUIRED?
	Sequence    int      `json:"sequence,omitempty"`    // #8994.02 .05 SEQUENCE NUMBER (default = position)
	Description []string `json:"description,omitempty"` // #8994.02 DESCRIPTION word-processing lines
}

RPCParamComp is one #8994.02 INPUT PARAMETER of an RPC: its name, type, max data length, required flag, sequence, and an optional DESCRIPTION. Type defaults to "literal"; sequence defaults to the parameter's 1-based position.

type RequiredBuild

type RequiredBuild struct {
	Name   string `json:"name"`   // NAMESPACE*VERSION[*PATCH]
	Action string `json:"action"` // one of the Action* constants
}

RequiredBuild is a KIDS Required Build (#11) — a prerequisite build + the action KIDS takes when it is absent.

type SetCodeSpec

type SetCodeSpec struct {
	Internal string `json:"internal"`
	External string `json:"external"`
}

SetCodeSpec is one internal:external value of a set-of-codes field.

type Spec

type Spec struct {
	Package        string          `json:"package"`         // NAMESPACE (e.g. ZZSKEL)
	Version        string          `json:"version"`         // e.g. 1.0
	Patch          string          `json:"patch,omitempty"` // e.g. 1 (optional)
	Components     Components      `json:"components"`
	RequiredBuilds []RequiredBuild `json:"requiredBuilds,omitempty"`
	EnvCheck       string          `json:"envCheck,omitempty"`    // environment-check routine (bare name, XPDENV)
	PreInstall     string          `json:"preInstall,omitempty"`  // pre-install routine entryref (TAG^RTN), run before component filing
	PostInstall    string          `json:"postInstall,omitempty"` // post-install routine entryref (TAG^RTN), run after component filing
	ICRs           []ICR           `json:"icrs,omitempty"`        // DBIA/ICR agreements the package relies on

	// ForeignRoutines names the routines this build intentionally OVERWRITES that
	// are NOT in the package namespace — the high-risk "splice a national routine"
	// case (the v-rpc-tap build overwrites XWBPRS from package VSLRT). Every routine
	// whose name does not start with Package must be declared here, or Validate
	// fails: the one intentional national overwrite is made explicit, reviewable,
	// and machine-checked, and it is the offline signal class-aware uninstall needs
	// to REFUSE a bare delete that would brick the foreign routine (see the v-pkg
	// mixed-build split-reversal proposal, D1).
	ForeignRoutines []string `json:"foreignRoutines,omitempty"`

	// AllowLongNames opts the build out of the legacy 8-char SAC routine-name
	// convention, raising the cap to the M engine limit (RoutineNameMaxLong).
	// The M-naming character rules still bind. This is a deliberate, committed
	// policy choice — see the org "modern routine-name length policy" ADR — and
	// is appropriate only for modern YDB/IRIS targets (it forgoes legacy
	// GT.M/Caché %RO portability and formal SAC/national release without a
	// later rename).
	AllowLongNames bool `json:"allowLongNames,omitempty"`
}

Spec is one KIDS build definition (kids/<pkg>.build.json).

func Load

func Load(path string) (*Spec, error)

Load reads and validates a build spec from a kids/<pkg>.build.json file.

func Parse

func Parse(data []byte) (*Spec, error)

Parse decodes a build spec from JSON (rejecting unknown fields — a typo'd key is an error, not a silent drop) and validates it.

func (*Spec) InstallName

func (s *Spec) InstallName() string

InstallName is the KIDS install name NAMESPACE*VERSION[*PATCH].

func (*Spec) Validate

func (s *Spec) Validate() error

Validate checks the spec is a usable KIDS build definition.