@milaboratories/pl-model-common 1.34.0 → 1.35.0

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { BlockSection, BlockSectionDelimiter, BlockSectionLink, BlockSectionLink
 import { CanonicalizedJson, JsonCompatible, JsonSerializable, StringifiedJson, bigintReplacer, canonicalizeJson, parseJson, stringifyJson } from "./json.js";
 import { BlockState, BlockStateV3 } from "./block_state.js";
 import { Branded } from "./branding.js";
-import { Option, PlRef, Ref, createPlRef, isPlRef, plRefsEqual, withEnrichments } from "./ref.js";
+import { DatasetInput, DatasetOption, Option, PlRef, PrimaryRef, Ref, createPlRef, createPrimaryRef, isPlRef, isPrimaryRef, plRefsEqual, withEnrichments } from "./ref.js";
 import { ResultCollection, ResultPoolEntry } from "./pool/entry.js";
 import { BlobLike, FileLike } from "./drivers/interfaces.js";
 import { ArchiveFormat, BlobToURLDriver, BlockUIURL, FolderURL, FrontendDriver, isBlockUIURL, isFolderURL } from "./drivers/urls.js";
@@ -16,22 +16,23 @@ import { ColumnFilter } from "./drivers/pframe/column_filter.js";
 import { BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, DataInfo, DataInfoEntries, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, PColumnDataEntry, PColumnKey, PColumnValue, PColumnValues, PColumnValuesEntry, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo } from "./drivers/pframe/data_info.js";
 import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredPColumnId, AnchoredPColumnSelector, LegacyAxisSelector, PColumnSelector, SingleAxisSelector, isAnchoredPColumnId, legacyColumnSelectorsToPredicate, matchAxis, matchPColumn } from "./drivers/pframe/spec/selectors.js";
 import { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, FilteredPColumn, FilteredPColumnId, isFilteredPColumn } from "./drivers/pframe/spec/filtered_column.js";
+import { PoolEntry, PoolEntryGuard } from "./pool_entry.js";
+import { AnchoredIdDeriver, ResolveAnchorsOptions, resolveAnchors } from "./drivers/pframe/spec/anchored.js";
+import { NativePObjectId, deriveNativeId } from "./drivers/pframe/spec/native_id.js";
+import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId } from "./drivers/pframe/table_common.js";
+import { SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryLinkerJoin, SpecQueryLinkerJoinLinker, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin } from "./drivers/pframe/query/query_spec.js";
+import { DataExprAxisRef, DataExprColumnRef, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryLinkerJoin, DataQueryLinkerJoinLinker, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin } from "./drivers/pframe/query/query_data.js";
+import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./drivers/pframe/query/utils.js";
+import { AxisQualification, BuildQueryInput, ColumnAxesWithQualifications, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsFilterStep, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, EvaluateQueryResponse, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher } from "./drivers/pframe/spec_driver.js";
+import { DiscoveredPColumn, DiscoveredPColumnId, createDiscoveredPColumn, createDiscoveredPColumnId, isDiscoveredPColumn, parseDiscoveredPColumnId, stringifyDiscoveredPColumnId } from "./drivers/pframe/spec/discovered_column.js";
 import { SUniversalPColumnId, UniversalPColumnId, parseColumnId, stringifyColumnId } from "./drivers/pframe/spec/ids.js";
 import { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec } from "./drivers/pframe/filter_spec.js";
 import { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded } from "./drivers/pframe/data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./drivers/pframe/find_columns.js";
-import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId } from "./drivers/pframe/table_common.js";
 import { PTable } from "./drivers/pframe/table.js";
-import { AnchoredIdDeriver, ResolveAnchorsOptions, resolveAnchors } from "./drivers/pframe/spec/anchored.js";
-import { NativePObjectId, deriveNativeId } from "./drivers/pframe/spec/native_id.js";
-import { SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryLinkerJoin, SpecQueryLinkerJoinLinker, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin } from "./drivers/pframe/query/query_spec.js";
 import { ArtificialColumnJoinEntry, CalculateTableDataRequest, CalculateTableDataResponse, ColumnJoinEntry, ConstantAxisFilter, FullJoin, FullPTableColumnData, InlineColumnJoinEntry, InnerJoin, JoinEntry, OuterJoin, PTableDef, PTableDefV2, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableSorting, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./drivers/pframe/table_calculate.js";
 import { UniqueValuesRequest, UniqueValuesResponse } from "./drivers/pframe/unique_values.js";
-import { DataExprAxisRef, DataExprColumnRef, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryLinkerJoin, DataQueryLinkerJoinLinker, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin } from "./drivers/pframe/query/query_data.js";
-import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./drivers/pframe/query/utils.js";
 import { CompositeLinkerMap, LinkerMap } from "./drivers/pframe/linker_columns.js";
-import { PoolEntry, PoolEntryGuard } from "./pool_entry.js";
-import { AxisQualification, BuildQueryInput, ColumnAxesWithQualifications, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsFilterStep, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, EvaluateQueryResponse, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher } from "./drivers/pframe/spec_driver.js";
 import { FileRange, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ListFilesResult, LocalImportFileHandle, LsDriver, LsEntry, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, getFileNameFromHandle, getFilePathFromHandle, isImportFileHandleIndex, isImportFileHandleUpload } from "./drivers/ls.js";
 import { ChunkedStreamReader, ChunkedStreamReaderOptions, ErrorHandlerStatus } from "./drivers/ChunkedStreamReader.js";
 import { PObject, PObjectId, PObjectSpec, ensurePColumn, extractAllColumns, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, mapPObjectData } from "./pool/spec.js";
@@ -61,4 +62,4 @@ import { Base64Compatible, Base64Encoded, base64Decode, base64Encode } from "./b
 import { assertNever, uniqueBy } from "./util.js";
 import { BasicHttpAuth, HttpAuth, parseHttpAuth, serializeHttpAuth } from "./httpAuth.js";
 import { ResourceTypeName, ResourceTypePrefix } from "./resource_types.js";
-export { AAxisSelector, ADomain, AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredIdDeriver, AnchoredPColumnId, AnchoredPColumnSelector, Annotation, AnnotationJson, AnyFunction, AnyLogHandle, ArchiveFormat, ArrayTypeUnion, ArtificialColumnJoinEntry, Assert, AssertKeysEqual, AuthorMarker, AxesId, AxesSpec, AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, AxisId, AxisQualification, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, Base64Compatible, Base64Encoded, BasicHttpAuth, BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, BlobDriver, BlobHandleAndSize, BlobLike, BlobToURLDriver, BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags, BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockOutputsBase, BlockRenderingMode, BlockSection, BlockSectionDelimiter, BlockSectionLink, BlockSectionLinkAppearance, BlockState, BlockStateV3, BlockUIURL, Branded, BuildQueryInput, CalculateTableDataRequest, CalculateTableDataResponse, CanonicalizedJson, ChunkedStreamReader, ChunkedStreamReaderOptions, Code, ColumnAxesWithQualifications, ColumnFilter, ColumnJoinEntry, ColumnValueType, CompositeLinkerMap, ConstantAxisFilter, ContentHandler, DataExprAxisRef, DataExprColumnRef, DataInfo, DataInfoEntries, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryLinkerJoin, DataQueryLinkerJoinLinker, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin, DefaultNavigationState, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsFilterStep, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, Domain, DomainJson, DriverKit, ErrorHandlerStatus, EvaluateQueryResponse, FileLike, FileRange, FilterKeysByPrefix, FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, FilteredPColumn, FilteredPColumnId, FindColumnsRequest, FindColumnsResponse, FolderURL, FrontendDriver, FullJoin, FullPTableColumnData, GetContentOptions, HttpAuth, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ImportProgress, ImportStatus, IncompatibleFlagsError, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, InferServiceKind, InferServiceModel, InferServiceUi, InlineColumnJoinEntry, InnerJoin, Is, IsSubtypeOf, JoinEntry, JsonCompatible, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, JsonSerializable, KnownServiceName, LegacyAxisSelector, LinkerMap, ListFilesResult, ListOptionBase, LiveLogHandle, LocalBlobHandle, LocalBlobHandleAndSize, LocalImportFileHandle, LogsDriver, LsDriver, LsEntry, MatcherMap, Metadata, MetadataJson, ModelServiceFactoryMap, ModelServiceRegistry, ModelServices, MultiAxisSelector, MultiColumnSelector, NativePObjectId, NavigationState, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, Option, OuterJoin, OutputWithStatus, PAxisName, PColumn, PColumnDataEntry, PColumnIdAndSpec, PColumnInfo, PColumnKey, PColumnLazy, PColumnName, PColumnSelector, PColumnSpec, PColumnSpecId, PColumnValue, PColumnValues, PColumnValuesEntry, PDataColumnSpec, PFrame, PFrameDef, PFrameDriver, PFrameDriverError, PFrameError, PFrameHandle, PFrameModelDriver, PFrameSpecDriver, PFrameSpecDriverError, PObject, PObjectId, PObjectSpec, PSpecPredicate, PTable, PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, PTableDef, PTableDefV2, PTableHandle, PTableNA, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableShape, PTableSorting, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PUniversalColumnSpec, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntry, PoolEntryGuard, ProgressLogWithInfo, RangeBytes, ReadyLogHandle, Ref, RemoteBlobHandle, RemoteBlobHandleAndSize, RequireServices, ResolveAnchorsOptions, ResourceTypeName, ResourceTypePrefix, ResultCollection, ResultOrError, ResultPoolEntry, RootFilterSpec, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, SUniversalPColumnId, SerializedError, ServiceAlreadyRegisteredError, ServiceBrand, ServiceDispatch, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceName, ServiceNameLiterals, ServiceNotRegisteredError, ServiceRequireFlags, ServiceType, ServiceTypesLike, Services, SingleAxisSelector, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, SpecExprAxisRef, SpecExprColumnRef, SpecFrameHandle, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryLinkerJoin, SpecQueryLinkerJoinLinker, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, StringMatcher, StringifiedJson, SupportedRequirement, TableRange, Trace, TraceEntry, UiError, UiServiceFactoryMap, UiServiceInjectorMap, UiServiceRegistry, UiServices, UniqueValuesRequest, UniqueValuesResponse, UniversalPColumnId, ValueOrError, ValueType, ValueTypeSupported, ValueWithUTag, ValueWithUTagAndAuthor, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAnyLogHandle, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableNA, isPartitionedDataInfoEntries, isPlRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };
+export { AAxisSelector, ADomain, AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredIdDeriver, AnchoredPColumnId, AnchoredPColumnSelector, Annotation, AnnotationJson, AnyFunction, AnyLogHandle, ArchiveFormat, ArrayTypeUnion, ArtificialColumnJoinEntry, Assert, AssertKeysEqual, AuthorMarker, AxesId, AxesSpec, AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, AxisId, AxisQualification, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, Base64Compatible, Base64Encoded, BasicHttpAuth, BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, BlobDriver, BlobHandleAndSize, BlobLike, BlobToURLDriver, BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags, BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockOutputsBase, BlockRenderingMode, BlockSection, BlockSectionDelimiter, BlockSectionLink, BlockSectionLinkAppearance, BlockState, BlockStateV3, BlockUIURL, Branded, BuildQueryInput, CalculateTableDataRequest, CalculateTableDataResponse, CanonicalizedJson, ChunkedStreamReader, ChunkedStreamReaderOptions, Code, ColumnAxesWithQualifications, ColumnFilter, ColumnJoinEntry, ColumnValueType, CompositeLinkerMap, ConstantAxisFilter, ContentHandler, DataExprAxisRef, DataExprColumnRef, DataInfo, DataInfoEntries, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryLinkerJoin, DataQueryLinkerJoinLinker, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin, DatasetInput, DatasetOption, DefaultNavigationState, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsFilterStep, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, DiscoveredPColumn, DiscoveredPColumnId, Domain, DomainJson, DriverKit, ErrorHandlerStatus, EvaluateQueryResponse, FileLike, FileRange, FilterKeysByPrefix, FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, FilteredPColumn, FilteredPColumnId, FindColumnsRequest, FindColumnsResponse, FolderURL, FrontendDriver, FullJoin, FullPTableColumnData, GetContentOptions, HttpAuth, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ImportProgress, ImportStatus, IncompatibleFlagsError, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, InferServiceKind, InferServiceModel, InferServiceUi, InlineColumnJoinEntry, InnerJoin, Is, IsSubtypeOf, JoinEntry, JsonCompatible, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, JsonSerializable, KnownServiceName, LegacyAxisSelector, LinkerMap, ListFilesResult, ListOptionBase, LiveLogHandle, LocalBlobHandle, LocalBlobHandleAndSize, LocalImportFileHandle, LogsDriver, LsDriver, LsEntry, MatcherMap, Metadata, MetadataJson, ModelServiceFactoryMap, ModelServiceRegistry, ModelServices, MultiAxisSelector, MultiColumnSelector, NativePObjectId, NavigationState, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, Option, OuterJoin, OutputWithStatus, PAxisName, PColumn, PColumnDataEntry, PColumnIdAndSpec, PColumnInfo, PColumnKey, PColumnLazy, PColumnName, PColumnSelector, PColumnSpec, PColumnSpecId, PColumnValue, PColumnValues, PColumnValuesEntry, PDataColumnSpec, PFrame, PFrameDef, PFrameDriver, PFrameDriverError, PFrameError, PFrameHandle, PFrameModelDriver, PFrameSpecDriver, PFrameSpecDriverError, PObject, PObjectId, PObjectSpec, PSpecPredicate, PTable, PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, PTableDef, PTableDefV2, PTableHandle, PTableNA, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableShape, PTableSorting, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PUniversalColumnSpec, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntry, PoolEntryGuard, PrimaryRef, ProgressLogWithInfo, RangeBytes, ReadyLogHandle, Ref, RemoteBlobHandle, RemoteBlobHandleAndSize, RequireServices, ResolveAnchorsOptions, ResourceTypeName, ResourceTypePrefix, ResultCollection, ResultOrError, ResultPoolEntry, RootFilterSpec, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, SUniversalPColumnId, SerializedError, ServiceAlreadyRegisteredError, ServiceBrand, ServiceDispatch, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceName, ServiceNameLiterals, ServiceNotRegisteredError, ServiceRequireFlags, ServiceType, ServiceTypesLike, Services, SingleAxisSelector, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, SpecExprAxisRef, SpecExprColumnRef, SpecFrameHandle, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryLinkerJoin, SpecQueryLinkerJoinLinker, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, StringMatcher, StringifiedJson, SupportedRequirement, TableRange, Trace, TraceEntry, UiError, UiServiceFactoryMap, UiServiceInjectorMap, UiServiceRegistry, UiServices, UniqueValuesRequest, UniqueValuesResponse, UniversalPColumnId, ValueOrError, ValueType, ValueTypeSupported, ValueWithUTag, ValueWithUTagAndAuthor, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createDiscoveredPColumn, createDiscoveredPColumnId, createPlRef, createPrimaryRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAnyLogHandle, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isDiscoveredPColumn, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableNA, isPartitionedDataInfoEntries, isPlRef, isPrimaryRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseDiscoveredPColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyDiscoveredPColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };

package/dist/index.js

@@ -22,6 +22,7 @@ import { ensurePColumn, extractAllColumns, isPColumn, isPColumnResult, isPColumn
 import { executePSpecPredicate } from "./pool/query.js";
 import { isAnchoredPColumnId, legacyColumnSelectorsToPredicate, matchAxis, matchPColumn } from "./drivers/pframe/spec/selectors.js";
 import { deriveNativeId } from "./drivers/pframe/spec/native_id.js";
+import { createDiscoveredPColumn, createDiscoveredPColumnId, isDiscoveredPColumn, parseDiscoveredPColumnId, stringifyDiscoveredPColumnId } from "./drivers/pframe/spec/discovered_column.js";
 import { LinkerMap } from "./drivers/pframe/linker_columns.js";
 import { ChunkedStreamReader } from "./drivers/ChunkedStreamReader.js";
 import "./drivers/index.js";
@@ -29,7 +30,7 @@ import { AllRequiresFeatureFlags, AllSupportsFeatureFlags } from "./flags/block_
 import { IncompatibleFlagsError, RuntimeCapabilities, checkBlockFlag, extractAllRequirements, extractAllSupports } from "./flags/flag_utils.js";
 import { DefaultNavigationState } from "./navigation.js";
 import { PlId, PlIdBytes, PlIdLength, digestPlId, plId, uniquePlId } from "./plid.js";
-import { PlRef, createPlRef, isPlRef, plRefsEqual, withEnrichments } from "./ref.js";
+import { PlRef, createPlRef, createPrimaryRef, isPlRef, isPrimaryRef, plRefsEqual, withEnrichments } from "./ref.js";
 import { mapValueInVOE } from "./value_or_error.js";
 import { base64Decode, base64Encode } from "./base64.js";
 import { parseHttpAuth, serializeHttpAuth } from "./httpAuth.js";
@@ -42,4 +43,4 @@ import { createUiServiceInjectors } from "./services/service_injector_factory.js
 import { SERVICE_METHOD_MAP, buildServiceInfo, resolveUiInjector } from "./services/service_injectors.js";
 import "./services/index.js";
 import { PoolEntryGuard } from "./pool_entry.js";
-export { AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchoredIdDeriver, Annotation, AnnotationJson, ChunkedStreamReader, Code, DefaultNavigationState, Domain, DomainJson, IncompatibleFlagsError, LinkerMap, ModelServiceRegistry, PAxisName, PColumnName, PFrameDriverError, PFrameError, PFrameSpecDriverError, PTableNA, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntryGuard, RangeBytes, ResourceTypeName, ResourceTypePrefix, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, ServiceAlreadyRegisteredError, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceNotRegisteredError, Services, UiError, UiServiceRegistry, ValueType, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAnyLogHandle, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableNA, isPartitionedDataInfoEntries, isPlRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };
+export { AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchoredIdDeriver, Annotation, AnnotationJson, ChunkedStreamReader, Code, DefaultNavigationState, Domain, DomainJson, IncompatibleFlagsError, LinkerMap, ModelServiceRegistry, PAxisName, PColumnName, PFrameDriverError, PFrameError, PFrameSpecDriverError, PTableNA, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntryGuard, RangeBytes, ResourceTypeName, ResourceTypePrefix, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, ServiceAlreadyRegisteredError, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceNotRegisteredError, Services, UiError, UiServiceRegistry, ValueType, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createDiscoveredPColumn, createDiscoveredPColumnId, createPlRef, createPrimaryRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAnyLogHandle, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isDiscoveredPColumn, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableNA, isPartitionedDataInfoEntries, isPlRef, isPrimaryRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseDiscoveredPColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyDiscoveredPColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };

package/dist/ref.cjs

@@ -55,6 +55,20 @@ function withEnrichments(ref, requireEnrichments = true) {
 		return rest;
 	}
 }
+function isPrimaryRef(value) {
+	return typeof value === "object" && value !== null && value.__isPrimaryRef === "v1" && "column" in value;
+}
+function createPrimaryRef(column, filter) {
+	if (filter !== void 0) return {
+		__isPrimaryRef: "v1",
+		column,
+		filter
+	};
+	else return {
+		__isPrimaryRef: "v1",
+		column
+	};
+}
 /** Compare two PlRefs and returns true if they are qual */
 function plRefsEqual(ref1, ref2, ignoreEnrichments = false) {
 	return ref1.blockId === ref2.blockId && ref1.name === ref2.name && (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments);
@@ -62,7 +76,9 @@ function plRefsEqual(ref1, ref2, ignoreEnrichments = false) {
 //#endregion
 exports.PlRef = PlRef;
 exports.createPlRef = createPlRef;
+exports.createPrimaryRef = createPrimaryRef;
 exports.isPlRef = isPlRef;
+exports.isPrimaryRef = isPrimaryRef;
 exports.plRefsEqual = plRefsEqual;
 exports.withEnrichments = withEnrichments;
 

package/dist/ref.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ref.cjs","names":["z"],"sources":["../src/ref.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const PlRef = z\n  .object({\n    __isRef: z\n      .literal(true)\n      .describe(\"Crucial marker for the block dependency tree reconstruction\"),\n    blockId: z.string().describe(\"Upstream block id\"),\n    name: z.string().describe(\"Name of the output provided to the upstream block's output context\"),\n    requireEnrichments: z\n      .literal(true)\n      .optional()\n      .describe(\n        \"True if current block that stores this reference in its args, may need enrichments \" +\n          \"for the references value originating from the blocks in between current and referenced block\",\n      ),\n  })\n  .describe(\n    \"Universal reference type, allowing to set block connections. It is crucial that \" +\n      \"{@link __isRef} is present and equal to true, internal logic relies on this marker \" +\n      \"to build block dependency trees.\",\n  )\n  .readonly();\nexport type PlRef = z.infer<typeof PlRef>;\n/** @deprecated use {@link PlRef} */\nexport type Ref = PlRef;\n\n/**\n * Type guard to check if a value is a PlRef.\n *\n * @param value - The value to check.\n * @returns True if the value is a PlRef, false otherwise.\n */\nexport function isPlRef(value: unknown): value is PlRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"__isRef\" in value &&\n    (value as { __isRef: unknown }).__isRef === true &&\n    \"blockId\" in value &&\n    \"name\" in value\n  );\n}\n\n/** Standard way how to communicate possible connections given specific\n * requirements for incoming data. */\nexport type Option = {\n  /** Fully rendered reference to be assigned for the intended field in block's\n   * args */\n  readonly ref: PlRef;\n\n  /** Label to be present for the user in i.e. drop-down list */\n  readonly label: string;\n};\n\n/**\n * Creates a PlRef with the given blockId and name.\n *\n * @param blockId - The blockId of the reference.\n * @param name - The name of the reference.\n * @param requireEnrichments - Whether the reference requires enrichments.\n */\nexport function createPlRef(blockId: string, name: string, requireEnrichments: boolean = false) {\n  if (requireEnrichments)\n    return {\n      __isRef: true,\n      blockId,\n      name,\n      requireEnrichments: true,\n    };\n  else\n    return {\n      __isRef: true,\n      blockId,\n      name,\n    };\n}\n\n/**\n * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the\n * requireEnrichments property.\n *\n * @param ref - The original PlRef object.\n * @param requireEnrichments - If true, the `requireEnrichments: true` property is added\n *   to the returned PlRef. If false, the `requireEnrichments` property is removed. Defaults to true.\n * @returns A new PlRef object with the `requireEnrichments` property set or removed accordingly.\n */\nexport function withEnrichments(ref: PlRef, requireEnrichments: boolean = true): PlRef {\n  if (requireEnrichments)\n    return {\n      ...ref,\n      requireEnrichments: true,\n    };\n  else {\n    const { requireEnrichments: _, ...rest } = ref;\n    return rest;\n  }\n}\n\n/** Compare two PlRefs and returns true if they are qual */\nexport function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments: boolean = false) {\n  return (\n    ref1.blockId === ref2.blockId &&\n    ref1.name === ref2.name &&\n    (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments)\n  );\n}\n"],"mappings":";;;AAEA,MAAa,QAAQA,IAAAA,EAClB,OAAO;CACN,SAASA,IAAAA,EACN,QAAQ,KAAK,CACb,SAAS,8DAA8D;CAC1E,SAASA,IAAAA,EAAE,QAAQ,CAAC,SAAS,oBAAoB;CACjD,MAAMA,IAAAA,EAAE,QAAQ,CAAC,SAAS,qEAAqE;CAC/F,oBAAoBA,IAAAA,EACjB,QAAQ,KAAK,CACb,UAAU,CACV,SACC,kLAED;CACJ,CAAC,CACD,SACC,sMAGD,CACA,UAAU;;;;;;;AAWb,SAAgB,QAAQ,OAAgC;AACtD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACZ,MAA+B,YAAY,QAC5C,aAAa,SACb,UAAU;;;;;;;;;AAsBd,SAAgB,YAAY,SAAiB,MAAc,qBAA8B,OAAO;AAC9F,KAAI,mBACF,QAAO;EACL,SAAS;EACT;EACA;EACA,oBAAoB;EACrB;KAED,QAAO;EACL,SAAS;EACT;EACA;EACD;;;;;;;;;;;AAYL,SAAgB,gBAAgB,KAAY,qBAA8B,MAAa;AACrF,KAAI,mBACF,QAAO;EACL,GAAG;EACH,oBAAoB;EACrB;MACE;EACH,MAAM,EAAE,oBAAoB,GAAG,GAAG,SAAS;AAC3C,SAAO;;;;AAKX,SAAgB,YAAY,MAAa,MAAa,oBAA6B,OAAO;AACxF,QACE,KAAK,YAAY,KAAK,WACtB,KAAK,SAAS,KAAK,SAClB,qBAAqB,KAAK,uBAAuB,KAAK"}
+{"version":3,"file":"ref.cjs","names":["z"],"sources":["../src/ref.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const PlRef = z\n  .object({\n    __isRef: z\n      .literal(true)\n      .describe(\"Crucial marker for the block dependency tree reconstruction\"),\n    blockId: z.string().describe(\"Upstream block id\"),\n    name: z.string().describe(\"Name of the output provided to the upstream block's output context\"),\n    requireEnrichments: z\n      .literal(true)\n      .optional()\n      .describe(\n        \"True if current block that stores this reference in its args, may need enrichments \" +\n          \"for the references value originating from the blocks in between current and referenced block\",\n      ),\n  })\n  .describe(\n    \"Universal reference type, allowing to set block connections. It is crucial that \" +\n      \"{@link __isRef} is present and equal to true, internal logic relies on this marker \" +\n      \"to build block dependency trees.\",\n  )\n  .readonly();\nexport type PlRef = z.infer<typeof PlRef>;\n/** @deprecated use {@link PlRef} */\nexport type Ref = PlRef;\n\n/**\n * Type guard to check if a value is a PlRef.\n *\n * @param value - The value to check.\n * @returns True if the value is a PlRef, false otherwise.\n */\nexport function isPlRef(value: unknown): value is PlRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"__isRef\" in value &&\n    (value as { __isRef: unknown }).__isRef === true &&\n    \"blockId\" in value &&\n    \"name\" in value\n  );\n}\n\n/** Standard way how to communicate possible connections given specific\n * requirements for incoming data. */\nexport type Option = {\n  /** Fully rendered reference to be assigned for the intended field in block's\n   * args */\n  readonly ref: PlRef;\n\n  /** Label to be present for the user in i.e. drop-down list */\n  readonly label: string;\n};\n\n/**\n * Creates a PlRef with the given blockId and name.\n *\n * @param blockId - The blockId of the reference.\n * @param name - The name of the reference.\n * @param requireEnrichments - Whether the reference requires enrichments.\n */\nexport function createPlRef(\n  blockId: string,\n  name: string,\n  requireEnrichments: boolean = false,\n): PlRef {\n  if (requireEnrichments)\n    return {\n      __isRef: true,\n      blockId,\n      name,\n      requireEnrichments: true,\n    };\n  else\n    return {\n      __isRef: true,\n      blockId,\n      name,\n    };\n}\n\n/**\n * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the\n * requireEnrichments property.\n *\n * @param ref - The original PlRef object.\n * @param requireEnrichments - If true, the `requireEnrichments: true` property is added\n *   to the returned PlRef. If false, the `requireEnrichments` property is removed. Defaults to true.\n * @returns A new PlRef object with the `requireEnrichments` property set or removed accordingly.\n */\nexport function withEnrichments(ref: PlRef, requireEnrichments: boolean = true): PlRef {\n  if (requireEnrichments)\n    return {\n      ...ref,\n      requireEnrichments: true,\n    };\n  else {\n    const { requireEnrichments: _, ...rest } = ref;\n    return rest;\n  }\n}\n\n/** Primary dataset reference with an optional filter. */\nexport type PrimaryRef = {\n  readonly __isPrimaryRef: \"v1\";\n  readonly column: PlRef;\n  readonly filter?: PlRef;\n};\n\nexport function isPrimaryRef(value: unknown): value is PrimaryRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    (value as { __isPrimaryRef?: unknown }).__isPrimaryRef === \"v1\" &&\n    \"column\" in value\n  );\n}\n\nexport function createPrimaryRef(column: PlRef, filter?: PlRef): PrimaryRef {\n  if (filter !== undefined) return { __isPrimaryRef: \"v1\", column, filter };\n  else return { __isPrimaryRef: \"v1\", column };\n}\n\n/** Block args accept either form — backward compatible. */\nexport type DatasetInput = PlRef | PrimaryRef;\n\n/** Dataset option with optional filter choices. */\nexport type DatasetOption = Option & {\n  readonly filters?: readonly Option[];\n};\n\n/** Compare two PlRefs and returns true if they are qual */\nexport function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments: boolean = false) {\n  return (\n    ref1.blockId === ref2.blockId &&\n    ref1.name === ref2.name &&\n    (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments)\n  );\n}\n"],"mappings":";;;AAEA,MAAa,QAAQA,IAAAA,EAClB,OAAO;CACN,SAASA,IAAAA,EACN,QAAQ,KAAK,CACb,SAAS,8DAA8D;CAC1E,SAASA,IAAAA,EAAE,QAAQ,CAAC,SAAS,oBAAoB;CACjD,MAAMA,IAAAA,EAAE,QAAQ,CAAC,SAAS,qEAAqE;CAC/F,oBAAoBA,IAAAA,EACjB,QAAQ,KAAK,CACb,UAAU,CACV,SACC,kLAED;CACJ,CAAC,CACD,SACC,sMAGD,CACA,UAAU;;;;;;;AAWb,SAAgB,QAAQ,OAAgC;AACtD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACZ,MAA+B,YAAY,QAC5C,aAAa,SACb,UAAU;;;;;;;;;AAsBd,SAAgB,YACd,SACA,MACA,qBAA8B,OACvB;AACP,KAAI,mBACF,QAAO;EACL,SAAS;EACT;EACA;EACA,oBAAoB;EACrB;KAED,QAAO;EACL,SAAS;EACT;EACA;EACD;;;;;;;;;;;AAYL,SAAgB,gBAAgB,KAAY,qBAA8B,MAAa;AACrF,KAAI,mBACF,QAAO;EACL,GAAG;EACH,oBAAoB;EACrB;MACE;EACH,MAAM,EAAE,oBAAoB,GAAG,GAAG,SAAS;AAC3C,SAAO;;;AAWX,SAAgB,aAAa,OAAqC;AAChE,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAAuC,mBAAmB,QAC3D,YAAY;;AAIhB,SAAgB,iBAAiB,QAAe,QAA4B;AAC1E,KAAI,WAAW,KAAA,EAAW,QAAO;EAAE,gBAAgB;EAAM;EAAQ;EAAQ;KACpE,QAAO;EAAE,gBAAgB;EAAM;EAAQ;;;AAY9C,SAAgB,YAAY,MAAa,MAAa,oBAA6B,OAAO;AACxF,QACE,KAAK,YAAY,KAAK,WACtB,KAAK,SAAS,KAAK,SAClB,qBAAqB,KAAK,uBAAuB,KAAK"}

package/dist/ref.d.ts

@@ -42,17 +42,7 @@ type Option = {
  * @param name - The name of the reference.
  * @param requireEnrichments - Whether the reference requires enrichments.
  */
-declare function createPlRef(blockId: string, name: string, requireEnrichments?: boolean): {
-  __isRef: boolean;
-  blockId: string;
-  name: string;
-  requireEnrichments: boolean;
-} | {
-  __isRef: boolean;
-  blockId: string;
-  name: string;
-  requireEnrichments?: undefined;
-};
+declare function createPlRef(blockId: string, name: string, requireEnrichments?: boolean): PlRef;
 /**
  * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the
  * requireEnrichments property.
@@ -63,8 +53,22 @@ declare function createPlRef(blockId: string, name: string, requireEnrichments?:
  * @returns A new PlRef object with the `requireEnrichments` property set or removed accordingly.
  */
 declare function withEnrichments(ref: PlRef, requireEnrichments?: boolean): PlRef;
+/** Primary dataset reference with an optional filter. */
+type PrimaryRef = {
+  readonly __isPrimaryRef: "v1";
+  readonly column: PlRef;
+  readonly filter?: PlRef;
+};
+declare function isPrimaryRef(value: unknown): value is PrimaryRef;
+declare function createPrimaryRef(column: PlRef, filter?: PlRef): PrimaryRef;
+/** Block args accept either form — backward compatible. */
+type DatasetInput = PlRef | PrimaryRef;
+/** Dataset option with optional filter choices. */
+type DatasetOption = Option & {
+  readonly filters?: readonly Option[];
+};
 /** Compare two PlRefs and returns true if they are qual */
 declare function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments?: boolean): boolean;
 //#endregion
-export { Option, PlRef, Ref, createPlRef, isPlRef, plRefsEqual, withEnrichments };
+export { DatasetInput, DatasetOption, Option, PlRef, PrimaryRef, Ref, createPlRef, createPrimaryRef, isPlRef, isPrimaryRef, plRefsEqual, withEnrichments };
 //# sourceMappingURL=ref.d.ts.map

package/dist/ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ref.d.ts","names":[],"sources":["../src/ref.ts"],"mappings":";;;cAEa,KAAA,EAAK,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;KAqBN,KAAA,GAAQ,CAAA,CAAE,KAAA,QAAa,KAAA;;KAEvB,GAAA,GAAM,KAAA;;;;;;;iBAQF,OAAA,CAAQ,KAAA,YAAiB,KAAA,IAAS,KAAA;;;KAatC,MAAA;;;WAGD,GAAA,EAAK,KAAA;WAGL,KAAA;AAAA;;;;;;;;iBAUK,WAAA,CAAY,OAAA,UAAiB,IAAA,UAAc,kBAAA;;;;;;;;;;;;AArC3D;;;;;AAQA;;;iBAsDgB,eAAA,CAAgB,GAAA,EAAK,KAAA,EAAO,kBAAA,aAAqC,KAAA;;iBAajE,WAAA,CAAY,IAAA,EAAM,KAAA,EAAO,IAAA,EAAM,KAAA,EAAO,iBAAA"}
+{"version":3,"file":"ref.d.ts","names":[],"sources":["../src/ref.ts"],"mappings":";;;cAEa,KAAA,EAAK,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;KAqBN,KAAA,GAAQ,CAAA,CAAE,KAAA,QAAa,KAAA;;KAEvB,GAAA,GAAM,KAAA;;;;;;;iBAQF,OAAA,CAAQ,KAAA,YAAiB,KAAA,IAAS,KAAA;;;KAatC,MAAA;;;WAGD,GAAA,EAAK,KAAA;WAGL,KAAA;AAAA;;;;;;;;iBAUK,WAAA,CACd,OAAA,UACA,IAAA,UACA,kBAAA,aACC,KAAA;;;AA3CH;;;;;;;iBAoEgB,eAAA,CAAgB,GAAA,EAAK,KAAA,EAAO,kBAAA,aAAqC,KAAA;;KAarE,UAAA;EAAA,SACD,cAAA;EAAA,SACA,MAAA,EAAQ,KAAA;EAAA,SACR,MAAA,GAAS,KAAA;AAAA;AAAA,iBAGJ,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,UAAA;AAAA,iBASvC,gBAAA,CAAiB,MAAA,EAAQ,KAAA,EAAO,MAAA,GAAS,KAAA,GAAQ,UAAA;;KAMrD,YAAA,GAAe,KAAA,GAAQ,UAAA;;KAGvB,aAAA,GAAgB,MAAA;EAAA,SACjB,OAAA,YAAmB,MAAA;AAAA;;iBAId,WAAA,CAAY,IAAA,EAAM,KAAA,EAAO,IAAA,EAAM,KAAA,EAAO,iBAAA"}

package/dist/ref.js

@@ -54,11 +54,25 @@ function withEnrichments(ref, requireEnrichments = true) {
 		return rest;
 	}
 }
+function isPrimaryRef(value) {
+	return typeof value === "object" && value !== null && value.__isPrimaryRef === "v1" && "column" in value;
+}
+function createPrimaryRef(column, filter) {
+	if (filter !== void 0) return {
+		__isPrimaryRef: "v1",
+		column,
+		filter
+	};
+	else return {
+		__isPrimaryRef: "v1",
+		column
+	};
+}
 /** Compare two PlRefs and returns true if they are qual */
 function plRefsEqual(ref1, ref2, ignoreEnrichments = false) {
 	return ref1.blockId === ref2.blockId && ref1.name === ref2.name && (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments);
 }
 //#endregion
-export { PlRef, createPlRef, isPlRef, plRefsEqual, withEnrichments };
+export { PlRef, createPlRef, createPrimaryRef, isPlRef, isPrimaryRef, plRefsEqual, withEnrichments };
 
 //# sourceMappingURL=ref.js.map

package/dist/ref.js.map

@@ -1 +1 @@
-{"version":3,"file":"ref.js","names":[],"sources":["../src/ref.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const PlRef = z\n  .object({\n    __isRef: z\n      .literal(true)\n      .describe(\"Crucial marker for the block dependency tree reconstruction\"),\n    blockId: z.string().describe(\"Upstream block id\"),\n    name: z.string().describe(\"Name of the output provided to the upstream block's output context\"),\n    requireEnrichments: z\n      .literal(true)\n      .optional()\n      .describe(\n        \"True if current block that stores this reference in its args, may need enrichments \" +\n          \"for the references value originating from the blocks in between current and referenced block\",\n      ),\n  })\n  .describe(\n    \"Universal reference type, allowing to set block connections. It is crucial that \" +\n      \"{@link __isRef} is present and equal to true, internal logic relies on this marker \" +\n      \"to build block dependency trees.\",\n  )\n  .readonly();\nexport type PlRef = z.infer<typeof PlRef>;\n/** @deprecated use {@link PlRef} */\nexport type Ref = PlRef;\n\n/**\n * Type guard to check if a value is a PlRef.\n *\n * @param value - The value to check.\n * @returns True if the value is a PlRef, false otherwise.\n */\nexport function isPlRef(value: unknown): value is PlRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"__isRef\" in value &&\n    (value as { __isRef: unknown }).__isRef === true &&\n    \"blockId\" in value &&\n    \"name\" in value\n  );\n}\n\n/** Standard way how to communicate possible connections given specific\n * requirements for incoming data. */\nexport type Option = {\n  /** Fully rendered reference to be assigned for the intended field in block's\n   * args */\n  readonly ref: PlRef;\n\n  /** Label to be present for the user in i.e. drop-down list */\n  readonly label: string;\n};\n\n/**\n * Creates a PlRef with the given blockId and name.\n *\n * @param blockId - The blockId of the reference.\n * @param name - The name of the reference.\n * @param requireEnrichments - Whether the reference requires enrichments.\n */\nexport function createPlRef(blockId: string, name: string, requireEnrichments: boolean = false) {\n  if (requireEnrichments)\n    return {\n      __isRef: true,\n      blockId,\n      name,\n      requireEnrichments: true,\n    };\n  else\n    return {\n      __isRef: true,\n      blockId,\n      name,\n    };\n}\n\n/**\n * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the\n * requireEnrichments property.\n *\n * @param ref - The original PlRef object.\n * @param requireEnrichments - If true, the `requireEnrichments: true` property is added\n *   to the returned PlRef. If false, the `requireEnrichments` property is removed. Defaults to true.\n * @returns A new PlRef object with the `requireEnrichments` property set or removed accordingly.\n */\nexport function withEnrichments(ref: PlRef, requireEnrichments: boolean = true): PlRef {\n  if (requireEnrichments)\n    return {\n      ...ref,\n      requireEnrichments: true,\n    };\n  else {\n    const { requireEnrichments: _, ...rest } = ref;\n    return rest;\n  }\n}\n\n/** Compare two PlRefs and returns true if they are qual */\nexport function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments: boolean = false) {\n  return (\n    ref1.blockId === ref2.blockId &&\n    ref1.name === ref2.name &&\n    (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments)\n  );\n}\n"],"mappings":";;AAEA,MAAa,QAAQ,EAClB,OAAO;CACN,SAAS,EACN,QAAQ,KAAK,CACb,SAAS,8DAA8D;CAC1E,SAAS,EAAE,QAAQ,CAAC,SAAS,oBAAoB;CACjD,MAAM,EAAE,QAAQ,CAAC,SAAS,qEAAqE;CAC/F,oBAAoB,EACjB,QAAQ,KAAK,CACb,UAAU,CACV,SACC,kLAED;CACJ,CAAC,CACD,SACC,sMAGD,CACA,UAAU;;;;;;;AAWb,SAAgB,QAAQ,OAAgC;AACtD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACZ,MAA+B,YAAY,QAC5C,aAAa,SACb,UAAU;;;;;;;;;AAsBd,SAAgB,YAAY,SAAiB,MAAc,qBAA8B,OAAO;AAC9F,KAAI,mBACF,QAAO;EACL,SAAS;EACT;EACA;EACA,oBAAoB;EACrB;KAED,QAAO;EACL,SAAS;EACT;EACA;EACD;;;;;;;;;;;AAYL,SAAgB,gBAAgB,KAAY,qBAA8B,MAAa;AACrF,KAAI,mBACF,QAAO;EACL,GAAG;EACH,oBAAoB;EACrB;MACE;EACH,MAAM,EAAE,oBAAoB,GAAG,GAAG,SAAS;AAC3C,SAAO;;;;AAKX,SAAgB,YAAY,MAAa,MAAa,oBAA6B,OAAO;AACxF,QACE,KAAK,YAAY,KAAK,WACtB,KAAK,SAAS,KAAK,SAClB,qBAAqB,KAAK,uBAAuB,KAAK"}
+{"version":3,"file":"ref.js","names":[],"sources":["../src/ref.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const PlRef = z\n  .object({\n    __isRef: z\n      .literal(true)\n      .describe(\"Crucial marker for the block dependency tree reconstruction\"),\n    blockId: z.string().describe(\"Upstream block id\"),\n    name: z.string().describe(\"Name of the output provided to the upstream block's output context\"),\n    requireEnrichments: z\n      .literal(true)\n      .optional()\n      .describe(\n        \"True if current block that stores this reference in its args, may need enrichments \" +\n          \"for the references value originating from the blocks in between current and referenced block\",\n      ),\n  })\n  .describe(\n    \"Universal reference type, allowing to set block connections. It is crucial that \" +\n      \"{@link __isRef} is present and equal to true, internal logic relies on this marker \" +\n      \"to build block dependency trees.\",\n  )\n  .readonly();\nexport type PlRef = z.infer<typeof PlRef>;\n/** @deprecated use {@link PlRef} */\nexport type Ref = PlRef;\n\n/**\n * Type guard to check if a value is a PlRef.\n *\n * @param value - The value to check.\n * @returns True if the value is a PlRef, false otherwise.\n */\nexport function isPlRef(value: unknown): value is PlRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"__isRef\" in value &&\n    (value as { __isRef: unknown }).__isRef === true &&\n    \"blockId\" in value &&\n    \"name\" in value\n  );\n}\n\n/** Standard way how to communicate possible connections given specific\n * requirements for incoming data. */\nexport type Option = {\n  /** Fully rendered reference to be assigned for the intended field in block's\n   * args */\n  readonly ref: PlRef;\n\n  /** Label to be present for the user in i.e. drop-down list */\n  readonly label: string;\n};\n\n/**\n * Creates a PlRef with the given blockId and name.\n *\n * @param blockId - The blockId of the reference.\n * @param name - The name of the reference.\n * @param requireEnrichments - Whether the reference requires enrichments.\n */\nexport function createPlRef(\n  blockId: string,\n  name: string,\n  requireEnrichments: boolean = false,\n): PlRef {\n  if (requireEnrichments)\n    return {\n      __isRef: true,\n      blockId,\n      name,\n      requireEnrichments: true,\n    };\n  else\n    return {\n      __isRef: true,\n      blockId,\n      name,\n    };\n}\n\n/**\n * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the\n * requireEnrichments property.\n *\n * @param ref - The original PlRef object.\n * @param requireEnrichments - If true, the `requireEnrichments: true` property is added\n *   to the returned PlRef. If false, the `requireEnrichments` property is removed. Defaults to true.\n * @returns A new PlRef object with the `requireEnrichments` property set or removed accordingly.\n */\nexport function withEnrichments(ref: PlRef, requireEnrichments: boolean = true): PlRef {\n  if (requireEnrichments)\n    return {\n      ...ref,\n      requireEnrichments: true,\n    };\n  else {\n    const { requireEnrichments: _, ...rest } = ref;\n    return rest;\n  }\n}\n\n/** Primary dataset reference with an optional filter. */\nexport type PrimaryRef = {\n  readonly __isPrimaryRef: \"v1\";\n  readonly column: PlRef;\n  readonly filter?: PlRef;\n};\n\nexport function isPrimaryRef(value: unknown): value is PrimaryRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    (value as { __isPrimaryRef?: unknown }).__isPrimaryRef === \"v1\" &&\n    \"column\" in value\n  );\n}\n\nexport function createPrimaryRef(column: PlRef, filter?: PlRef): PrimaryRef {\n  if (filter !== undefined) return { __isPrimaryRef: \"v1\", column, filter };\n  else return { __isPrimaryRef: \"v1\", column };\n}\n\n/** Block args accept either form — backward compatible. */\nexport type DatasetInput = PlRef | PrimaryRef;\n\n/** Dataset option with optional filter choices. */\nexport type DatasetOption = Option & {\n  readonly filters?: readonly Option[];\n};\n\n/** Compare two PlRefs and returns true if they are qual */\nexport function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments: boolean = false) {\n  return (\n    ref1.blockId === ref2.blockId &&\n    ref1.name === ref2.name &&\n    (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments)\n  );\n}\n"],"mappings":";;AAEA,MAAa,QAAQ,EAClB,OAAO;CACN,SAAS,EACN,QAAQ,KAAK,CACb,SAAS,8DAA8D;CAC1E,SAAS,EAAE,QAAQ,CAAC,SAAS,oBAAoB;CACjD,MAAM,EAAE,QAAQ,CAAC,SAAS,qEAAqE;CAC/F,oBAAoB,EACjB,QAAQ,KAAK,CACb,UAAU,CACV,SACC,kLAED;CACJ,CAAC,CACD,SACC,sMAGD,CACA,UAAU;;;;;;;AAWb,SAAgB,QAAQ,OAAgC;AACtD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACZ,MAA+B,YAAY,QAC5C,aAAa,SACb,UAAU;;;;;;;;;AAsBd,SAAgB,YACd,SACA,MACA,qBAA8B,OACvB;AACP,KAAI,mBACF,QAAO;EACL,SAAS;EACT;EACA;EACA,oBAAoB;EACrB;KAED,QAAO;EACL,SAAS;EACT;EACA;EACD;;;;;;;;;;;AAYL,SAAgB,gBAAgB,KAAY,qBAA8B,MAAa;AACrF,KAAI,mBACF,QAAO;EACL,GAAG;EACH,oBAAoB;EACrB;MACE;EACH,MAAM,EAAE,oBAAoB,GAAG,GAAG,SAAS;AAC3C,SAAO;;;AAWX,SAAgB,aAAa,OAAqC;AAChE,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAAuC,mBAAmB,QAC3D,YAAY;;AAIhB,SAAgB,iBAAiB,QAAe,QAA4B;AAC1E,KAAI,WAAW,KAAA,EAAW,QAAO;EAAE,gBAAgB;EAAM;EAAQ;EAAQ;KACpE,QAAO;EAAE,gBAAgB;EAAM;EAAQ;;;AAY9C,SAAgB,YAAY,MAAa,MAAa,oBAA6B,OAAO;AACxF,QACE,KAAK,YAAY,KAAK,WACtB,KAAK,SAAS,KAAK,SAClB,qBAAqB,KAAK,uBAAuB,KAAK"}

package/dist/services/service_types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"service_types.cjs","names":["ServiceInvalidIdError","ServiceAlreadyRegisteredError"],"sources":["../../src/services/service_types.ts"],"sourcesContent":["import { UnionToIntersection } from \"@milaboratories/helpers\";\nimport type { Branded } from \"../branding\";\nimport { ServiceAlreadyRegisteredError, ServiceInvalidIdError } from \"../errors\";\nimport type { Services } from \"./service_declarations\";\n\nexport type ServiceTypesLike<\n  Model = unknown,\n  Ui = unknown,\n  Kind extends ServiceType = ServiceType,\n> = {\n  readonly __types?: { model: Model; ui: Ui; kind: Kind };\n};\n\nexport type InferServiceModel<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<infer M, unknown, ServiceType> ? M : unknown;\n\nexport type InferServiceUi<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, infer U, ServiceType> ? U : unknown;\n\nexport type InferServiceKind<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, unknown, infer K> ? K : ServiceType;\n\nexport type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded<string, S>;\n\nexport type ServiceType = \"node\" | \"wasm\";\n\nconst SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;\n\nexport const { service, isNodeService } = (() => {\n  const typeMap = new Map<string, ServiceType>();\n  return {\n    service<Model, Ui>() {\n      return <K extends ServiceType, N extends string>(options: {\n        readonly type: K;\n        readonly name: N;\n      }): Branded<N, ServiceTypesLike<Model, Ui, K>> => {\n        const { name, type } = options;\n        if (!SERVICE_ID_PATTERN.test(name)) {\n          throw new ServiceInvalidIdError(\n            `Invalid service ID \"${name}\": must match ${SERVICE_ID_PATTERN}`,\n          );\n        }\n        if (typeMap.has(name)) {\n          throw new ServiceAlreadyRegisteredError(`Service \"${name}\" already registered`);\n        }\n        typeMap.set(name, type);\n        return name as Branded<N, ServiceTypesLike<Model, Ui, K>>;\n      };\n    },\n    isNodeService(id: ServiceName): boolean {\n      return typeMap.get(id) === \"node\";\n    },\n  };\n})();\n\nexport function serviceFnKey(serviceId: string, method = \"\"): string {\n  return `service:${serviceId}:${method}`;\n}\n\nexport type ServiceBrand<T> =\n  T extends Branded<string, infer S extends ServiceTypesLike> ? S : never;\n\nexport type ModelServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceModel<ServiceBrand<SMap[K]>>) | null;\n};\n\nexport type UiServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceUi<ServiceBrand<SMap[K]>>) | null;\n};\n\n/** Contract between any service provider and any service consumer. */\nexport interface ServiceDispatch {\n  getServiceNames(): ServiceName[];\n  getServiceMethods(serviceId: ServiceName): string[];\n  callServiceMethod(serviceId: ServiceName, method: string, ...args: unknown[]): unknown;\n}\n\n// Auto-derived types from the Services const in service_declarations.ts.\n// Adding a service to Services automatically updates all of these.\n\ntype SMap = typeof Services;\n\ntype ExtractServiceName<T> = T extends Branded<infer N extends string, any> ? N : never;\n\n/** Model-side service interfaces keyed by service name literal. */\nexport type ModelServices = {\n  [K in keyof SMap as ExtractServiceName<SMap[K]>]: InferServiceModel<ServiceBrand<SMap[K]>>;\n};\n\n/** UI-side service interfaces keyed by service name literal. */\nexport type UiServices = {\n  [K in keyof SMap as ExtractServiceName<SMap[K]>]: InferServiceUi<ServiceBrand<SMap[K]>>;\n};\n\n/** Map from Services keys to their unbranded string name literals. */\nexport type ServiceNameLiterals = {\n  [K in keyof SMap]: ExtractServiceName<SMap[K]>;\n};\n\n/** Auto-derived requires* feature flags from Services keys. */\nexport type ServiceRequireFlags = {\n  [K in keyof SMap as `requires${K & string}`]?: boolean;\n};\n\nexport type RequireServices<T extends ServiceName> = UnionToIntersection<\n  T extends Branded<infer N extends string, infer S extends ServiceTypesLike>\n    ? Record<N, InferServiceModel<S>>\n    : never\n>;\n"],"mappings":";;AA0BA,MAAM,qBAAqB;AAE3B,MAAa,EAAE,SAAS,yBAAyB;CAC/C,MAAM,0BAAU,IAAI,KAA0B;AAC9C,QAAO;EACL,UAAqB;AACnB,WAAiD,YAGC;IAChD,MAAM,EAAE,MAAM,SAAS;AACvB,QAAI,CAAC,mBAAmB,KAAK,KAAK,CAChC,OAAM,IAAIA,eAAAA,sBACR,uBAAuB,KAAK,gBAAgB,qBAC7C;AAEH,QAAI,QAAQ,IAAI,KAAK,CACnB,OAAM,IAAIC,eAAAA,8BAA8B,YAAY,KAAK,sBAAsB;AAEjF,YAAQ,IAAI,MAAM,KAAK;AACvB,WAAO;;;EAGX,cAAc,IAA0B;AACtC,UAAO,QAAQ,IAAI,GAAG,KAAK;;EAE9B;IACC;AAEJ,SAAgB,aAAa,WAAmB,SAAS,IAAY;AACnE,QAAO,WAAW,UAAU,GAAG"}
+{"version":3,"file":"service_types.cjs","names":["ServiceInvalidIdError","ServiceAlreadyRegisteredError"],"sources":["../../src/services/service_types.ts"],"sourcesContent":["import { UnionToIntersection } from \"@milaboratories/helpers\";\nimport type { Branded } from \"../branding\";\nimport { ServiceAlreadyRegisteredError, ServiceInvalidIdError } from \"../errors\";\nimport type { Services } from \"./service_declarations\";\n\nexport type ServiceTypesLike<\n  Model = unknown,\n  Ui = unknown,\n  Kind extends ServiceType = ServiceType,\n> = {\n  readonly __types?: { model: Model; ui: Ui; kind: Kind };\n};\n\nexport type InferServiceModel<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<infer M, unknown, ServiceType> ? M : unknown;\n\nexport type InferServiceUi<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, infer U, ServiceType> ? U : unknown;\n\nexport type InferServiceKind<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, unknown, infer K> ? K : ServiceType;\n\nexport type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded<string, S>;\n\nexport type ServiceType = \"node\" | \"wasm\";\n\nconst SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;\n\nexport const { service, isNodeService } = (() => {\n  const typeMap = new Map<string, ServiceType>();\n  return {\n    service<Model, Ui>() {\n      return <K extends ServiceType, N extends string>(options: {\n        readonly type: K;\n        readonly name: N;\n      }): Branded<N, ServiceTypesLike<Model, Ui, K>> => {\n        const { name, type } = options;\n        if (!SERVICE_ID_PATTERN.test(name)) {\n          throw new ServiceInvalidIdError(\n            `Invalid service ID \"${name}\": must match ${SERVICE_ID_PATTERN}`,\n          );\n        }\n        if (typeMap.has(name)) {\n          throw new ServiceAlreadyRegisteredError(`Service \"${name}\" already registered`);\n        }\n        typeMap.set(name, type);\n        return name as Branded<N, ServiceTypesLike<Model, Ui, K>>;\n      };\n    },\n    isNodeService(id: ServiceName): boolean {\n      return typeMap.get(id) === \"node\";\n    },\n  };\n})();\n\nexport function serviceFnKey(serviceId: string, method = \"\"): string {\n  return `service:${serviceId}:${method}`;\n}\n\nexport type ServiceBrand<T> =\n  T extends Branded<string, infer S extends ServiceTypesLike> ? S : never;\n\nexport type ModelServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceModel<ServiceBrand<SMap[K]>>) | null;\n};\n\nexport type UiServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceUi<ServiceBrand<SMap[K]>>) | null;\n};\n\n/** Contract between any service provider and any service consumer. */\nexport interface ServiceDispatch {\n  getServiceNames(): ServiceName[];\n  getServiceMethods(serviceId: ServiceName): string[];\n  callServiceMethod(serviceId: ServiceName, method: string, ...args: unknown[]): unknown;\n}\n\n// Auto-derived types from the Services const in service_declarations.ts.\n// Adding a service to Services automatically updates all of these.\n\ntype TServices = typeof Services;\n\ntype ExtractServiceName<T> = T extends Branded<infer N extends string, any> ? N : never;\n\n/** Model-side service interfaces keyed by service name literal. */\nexport type ModelServices = {\n  [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceModel<\n    ServiceBrand<TServices[K]>\n  >;\n};\n\n/** UI-side service interfaces keyed by service name literal. */\nexport type UiServices = {\n  [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<\n    ServiceBrand<TServices[K]>\n  >;\n};\n\n/** Map from Services keys to their unbranded string name literals. */\nexport type ServiceNameLiterals = {\n  [K in keyof TServices]: ExtractServiceName<TServices[K]>;\n};\n\n/** Auto-derived requires* feature flags from Services keys. */\nexport type ServiceRequireFlags = {\n  [K in keyof TServices as `requires${K & string}`]?: boolean;\n};\n\nexport type RequireServices<T extends ServiceName> = UnionToIntersection<\n  T extends Branded<infer N extends string, infer S extends ServiceTypesLike>\n    ? Record<N, InferServiceModel<S>>\n    : never\n>;\n"],"mappings":";;AA0BA,MAAM,qBAAqB;AAE3B,MAAa,EAAE,SAAS,yBAAyB;CAC/C,MAAM,0BAAU,IAAI,KAA0B;AAC9C,QAAO;EACL,UAAqB;AACnB,WAAiD,YAGC;IAChD,MAAM,EAAE,MAAM,SAAS;AACvB,QAAI,CAAC,mBAAmB,KAAK,KAAK,CAChC,OAAM,IAAIA,eAAAA,sBACR,uBAAuB,KAAK,gBAAgB,qBAC7C;AAEH,QAAI,QAAQ,IAAI,KAAK,CACnB,OAAM,IAAIC,eAAAA,8BAA8B,YAAY,KAAK,sBAAsB;AAEjF,YAAQ,IAAI,MAAM,KAAK;AACvB,WAAO;;;EAGX,cAAc,IAA0B;AACtC,UAAO,QAAQ,IAAI,GAAG,KAAK;;EAE9B;IACC;AAEJ,SAAgB,aAAa,WAAmB,SAAS,IAAY;AACnE,QAAO,WAAW,UAAU,GAAG"}

package/dist/services/service_types.d.ts

@@ -29,16 +29,16 @@ interface ServiceDispatch {
   getServiceMethods(serviceId: ServiceName): string[];
   callServiceMethod(serviceId: ServiceName, method: string, ...args: unknown[]): unknown;
 }
-type SMap = typeof Services;
+type TServices = typeof Services;
 type ExtractServiceName<T> = T extends Branded$1<infer N extends string, any> ? N : never;
 /** Model-side service interfaces keyed by service name literal. */
-type ModelServices = { [K in keyof SMap as ExtractServiceName<SMap[K]>]: InferServiceModel<ServiceBrand<SMap[K]>> };
+type ModelServices = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceModel<ServiceBrand<TServices[K]>> };
 /** UI-side service interfaces keyed by service name literal. */
-type UiServices = { [K in keyof SMap as ExtractServiceName<SMap[K]>]: InferServiceUi<ServiceBrand<SMap[K]>> };
+type UiServices = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<ServiceBrand<TServices[K]>> };
 /** Map from Services keys to their unbranded string name literals. */
-type ServiceNameLiterals = { [K in keyof SMap]: ExtractServiceName<SMap[K]> };
+type ServiceNameLiterals = { [K in keyof TServices]: ExtractServiceName<TServices[K]> };
 /** Auto-derived requires* feature flags from Services keys. */
-type ServiceRequireFlags = { [K in keyof SMap as `requires${K & string}`]?: boolean };
+type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean };
 type RequireServices<T extends ServiceName> = UnionToIntersection<T extends Branded$1<infer N extends string, infer S extends ServiceTypesLike> ? Record<N, InferServiceModel<S>> : never>;
 //#endregion
 export { InferServiceKind, InferServiceModel, InferServiceUi, ModelServiceFactoryMap, ModelServices, RequireServices, ServiceBrand, ServiceDispatch, ServiceName, ServiceNameLiterals, ServiceRequireFlags, ServiceType, ServiceTypesLike, UiServiceFactoryMap, UiServices, isNodeService, service, serviceFnKey };

package/dist/services/service_types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service_types.d.ts","names":[],"sources":["../../src/services/service_types.ts"],"mappings":";;;;;KAKY,gBAAA,6CAGG,WAAA,GAAc,WAAA;EAAA,SAElB,OAAA;IAAY,KAAA,EAAO,KAAA;IAAO,EAAA,EAAI,EAAA;IAAI,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,KAGvC,iBAAA,WAA4B,gBAAA,IACtC,CAAA,SAAU,gBAAA,mBAAmC,WAAA,IAAe,CAAA;AAAA,KAElD,cAAA,WAAyB,gBAAA,IACnC,CAAA,SAAU,gBAAA,mBAAmC,WAAA,IAAe,CAAA;AAAA,KAElD,gBAAA,WAA2B,gBAAA,IACrC,CAAA,SAAU,gBAAA,8BAA8C,CAAA,GAAI,WAAA;AAAA,KAElD,WAAA,WAAsB,gBAAA,GAAmB,gBAAA,IAAoB,SAAA,SAAgB,CAAA;AAAA,KAE7E,WAAA;AAAA,cAIG,OAAA,8BAIS,WAAA,oBAA6B,OAAA;IAAA,SACpC,IAAA,EAAM,CAAA;IAAA,SACN,IAAA,EAAM,CAAA;EAAA,MACb,SAAA,CAAQ,CAAA,EAAG,gBAAA,CAAiB,KAAA,EAAO,EAAA,EAAI,CAAA,IAAA,aAAA,GAPZ,EAAA,EAqBf,WAAA;AAAA,iBAMN,YAAA,CAAa,SAAA,UAAmB,MAAA;AAAA,KAIpC,YAAA,MACV,CAAA,SAAU,SAAA,yBAAgC,gBAAA,IAAoB,CAAA;AAAA,KAEpD,sBAAA,cAAoC,MAAA,SAAe,WAAA,mBACjD,IAAA,UAAc,iBAAA,CAAkB,YAAA,CAAa,IAAA,CAAK,CAAA;AAAA,KAGpD,mBAAA,cAAiC,MAAA,SAAe,WAAA,mBAC9C,IAAA,UAAc,cAAA,CAAe,YAAA,CAAa,IAAA,CAAK,CAAA;;UAI5C,eAAA;EACf,eAAA,IAAmB,WAAA;EACnB,iBAAA,CAAkB,SAAA,EAAW,WAAA;EAC7B,iBAAA,CAAkB,SAAA,EAAW,WAAA,EAAa,MAAA,aAAmB,IAAA;AAAA;AAAA,KAM1D,IAAA,UAAc,QAAA;AAAA,KAEd,kBAAA,MAAwB,CAAA,SAAU,SAAA,gCAAuC,CAAA;;KAGlE,aAAA,iBACE,IAAA,IAAQ,kBAAA,CAAmB,IAAA,CAAK,CAAA,KAAM,iBAAA,CAAkB,YAAA,CAAa,IAAA,CAAK,CAAA;;KAI5E,UAAA,iBACE,IAAA,IAAQ,kBAAA,CAAmB,IAAA,CAAK,CAAA,KAAM,cAAA,CAAe,YAAA,CAAa,IAAA,CAAK,CAAA;;KAIzE,mBAAA,iBACE,IAAA,GAAO,kBAAA,CAAmB,IAAA,CAAK,CAAA;AAhF7C;AAAA,KAoFY,mBAAA,iBACE,IAAA,eAAmB,CAAA;AAAA,KAGrB,eAAA,WAA0B,WAAA,IAAe,mBAAA,CACnD,CAAA,SAAU,SAAA,yCAAgD,gBAAA,IACtD,MAAA,CAAO,CAAA,EAAG,iBAAA,CAAkB,CAAA"}
+{"version":3,"file":"service_types.d.ts","names":[],"sources":["../../src/services/service_types.ts"],"mappings":";;;;;KAKY,gBAAA,6CAGG,WAAA,GAAc,WAAA;EAAA,SAElB,OAAA;IAAY,KAAA,EAAO,KAAA;IAAO,EAAA,EAAI,EAAA;IAAI,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,KAGvC,iBAAA,WAA4B,gBAAA,IACtC,CAAA,SAAU,gBAAA,mBAAmC,WAAA,IAAe,CAAA;AAAA,KAElD,cAAA,WAAyB,gBAAA,IACnC,CAAA,SAAU,gBAAA,mBAAmC,WAAA,IAAe,CAAA;AAAA,KAElD,gBAAA,WAA2B,gBAAA,IACrC,CAAA,SAAU,gBAAA,8BAA8C,CAAA,GAAI,WAAA;AAAA,KAElD,WAAA,WAAsB,gBAAA,GAAmB,gBAAA,IAAoB,SAAA,SAAgB,CAAA;AAAA,KAE7E,WAAA;AAAA,cAIG,OAAA,8BAIS,WAAA,oBAA6B,OAAA;IAAA,SACpC,IAAA,EAAM,CAAA;IAAA,SACN,IAAA,EAAM,CAAA;EAAA,MACb,SAAA,CAAQ,CAAA,EAAG,gBAAA,CAAiB,KAAA,EAAO,EAAA,EAAI,CAAA,IAAA,aAAA,GAPZ,EAAA,EAqBf,WAAA;AAAA,iBAMN,YAAA,CAAa,SAAA,UAAmB,MAAA;AAAA,KAIpC,YAAA,MACV,CAAA,SAAU,SAAA,yBAAgC,gBAAA,IAAoB,CAAA;AAAA,KAEpD,sBAAA,cAAoC,MAAA,SAAe,WAAA,mBACjD,IAAA,UAAc,iBAAA,CAAkB,YAAA,CAAa,IAAA,CAAK,CAAA;AAAA,KAGpD,mBAAA,cAAiC,MAAA,SAAe,WAAA,mBAC9C,IAAA,UAAc,cAAA,CAAe,YAAA,CAAa,IAAA,CAAK,CAAA;;UAI5C,eAAA;EACf,eAAA,IAAmB,WAAA;EACnB,iBAAA,CAAkB,SAAA,EAAW,WAAA;EAC7B,iBAAA,CAAkB,SAAA,EAAW,WAAA,EAAa,MAAA,aAAmB,IAAA;AAAA;AAAA,KAM1D,SAAA,UAAmB,QAAA;AAAA,KAEnB,kBAAA,MAAwB,CAAA,SAAU,SAAA,gCAAuC,CAAA;;KAGlE,aAAA,iBACE,SAAA,IAAa,kBAAA,CAAmB,SAAA,CAAU,CAAA,KAAM,iBAAA,CAC1D,YAAA,CAAa,SAAA,CAAU,CAAA;;KAKf,UAAA,iBACE,SAAA,IAAa,kBAAA,CAAmB,SAAA,CAAU,CAAA,KAAM,cAAA,CAC1D,YAAA,CAAa,SAAA,CAAU,CAAA;;KAKf,mBAAA,iBACE,SAAA,GAAY,kBAAA,CAAmB,SAAA,CAAU,CAAA;AApFvD;AAAA,KAwFY,mBAAA,iBACE,SAAA,eAAwB,CAAA;AAAA,KAG1B,eAAA,WAA0B,WAAA,IAAe,mBAAA,CACnD,CAAA,SAAU,SAAA,yCAAgD,gBAAA,IACtD,MAAA,CAAO,CAAA,EAAG,iBAAA,CAAkB,CAAA"}

package/dist/services/service_types.js.map

@@ -1 +1 @@
-{"version":3,"file":"service_types.js","names":[],"sources":["../../src/services/service_types.ts"],"sourcesContent":["import { UnionToIntersection } from \"@milaboratories/helpers\";\nimport type { Branded } from \"../branding\";\nimport { ServiceAlreadyRegisteredError, ServiceInvalidIdError } from \"../errors\";\nimport type { Services } from \"./service_declarations\";\n\nexport type ServiceTypesLike<\n  Model = unknown,\n  Ui = unknown,\n  Kind extends ServiceType = ServiceType,\n> = {\n  readonly __types?: { model: Model; ui: Ui; kind: Kind };\n};\n\nexport type InferServiceModel<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<infer M, unknown, ServiceType> ? M : unknown;\n\nexport type InferServiceUi<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, infer U, ServiceType> ? U : unknown;\n\nexport type InferServiceKind<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, unknown, infer K> ? K : ServiceType;\n\nexport type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded<string, S>;\n\nexport type ServiceType = \"node\" | \"wasm\";\n\nconst SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;\n\nexport const { service, isNodeService } = (() => {\n  const typeMap = new Map<string, ServiceType>();\n  return {\n    service<Model, Ui>() {\n      return <K extends ServiceType, N extends string>(options: {\n        readonly type: K;\n        readonly name: N;\n      }): Branded<N, ServiceTypesLike<Model, Ui, K>> => {\n        const { name, type } = options;\n        if (!SERVICE_ID_PATTERN.test(name)) {\n          throw new ServiceInvalidIdError(\n            `Invalid service ID \"${name}\": must match ${SERVICE_ID_PATTERN}`,\n          );\n        }\n        if (typeMap.has(name)) {\n          throw new ServiceAlreadyRegisteredError(`Service \"${name}\" already registered`);\n        }\n        typeMap.set(name, type);\n        return name as Branded<N, ServiceTypesLike<Model, Ui, K>>;\n      };\n    },\n    isNodeService(id: ServiceName): boolean {\n      return typeMap.get(id) === \"node\";\n    },\n  };\n})();\n\nexport function serviceFnKey(serviceId: string, method = \"\"): string {\n  return `service:${serviceId}:${method}`;\n}\n\nexport type ServiceBrand<T> =\n  T extends Branded<string, infer S extends ServiceTypesLike> ? S : never;\n\nexport type ModelServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceModel<ServiceBrand<SMap[K]>>) | null;\n};\n\nexport type UiServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceUi<ServiceBrand<SMap[K]>>) | null;\n};\n\n/** Contract between any service provider and any service consumer. */\nexport interface ServiceDispatch {\n  getServiceNames(): ServiceName[];\n  getServiceMethods(serviceId: ServiceName): string[];\n  callServiceMethod(serviceId: ServiceName, method: string, ...args: unknown[]): unknown;\n}\n\n// Auto-derived types from the Services const in service_declarations.ts.\n// Adding a service to Services automatically updates all of these.\n\ntype SMap = typeof Services;\n\ntype ExtractServiceName<T> = T extends Branded<infer N extends string, any> ? N : never;\n\n/** Model-side service interfaces keyed by service name literal. */\nexport type ModelServices = {\n  [K in keyof SMap as ExtractServiceName<SMap[K]>]: InferServiceModel<ServiceBrand<SMap[K]>>;\n};\n\n/** UI-side service interfaces keyed by service name literal. */\nexport type UiServices = {\n  [K in keyof SMap as ExtractServiceName<SMap[K]>]: InferServiceUi<ServiceBrand<SMap[K]>>;\n};\n\n/** Map from Services keys to their unbranded string name literals. */\nexport type ServiceNameLiterals = {\n  [K in keyof SMap]: ExtractServiceName<SMap[K]>;\n};\n\n/** Auto-derived requires* feature flags from Services keys. */\nexport type ServiceRequireFlags = {\n  [K in keyof SMap as `requires${K & string}`]?: boolean;\n};\n\nexport type RequireServices<T extends ServiceName> = UnionToIntersection<\n  T extends Branded<infer N extends string, infer S extends ServiceTypesLike>\n    ? Record<N, InferServiceModel<S>>\n    : never\n>;\n"],"mappings":";;AA0BA,MAAM,qBAAqB;AAE3B,MAAa,EAAE,SAAS,yBAAyB;CAC/C,MAAM,0BAAU,IAAI,KAA0B;AAC9C,QAAO;EACL,UAAqB;AACnB,WAAiD,YAGC;IAChD,MAAM,EAAE,MAAM,SAAS;AACvB,QAAI,CAAC,mBAAmB,KAAK,KAAK,CAChC,OAAM,IAAI,sBACR,uBAAuB,KAAK,gBAAgB,qBAC7C;AAEH,QAAI,QAAQ,IAAI,KAAK,CACnB,OAAM,IAAI,8BAA8B,YAAY,KAAK,sBAAsB;AAEjF,YAAQ,IAAI,MAAM,KAAK;AACvB,WAAO;;;EAGX,cAAc,IAA0B;AACtC,UAAO,QAAQ,IAAI,GAAG,KAAK;;EAE9B;IACC;AAEJ,SAAgB,aAAa,WAAmB,SAAS,IAAY;AACnE,QAAO,WAAW,UAAU,GAAG"}
+{"version":3,"file":"service_types.js","names":[],"sources":["../../src/services/service_types.ts"],"sourcesContent":["import { UnionToIntersection } from \"@milaboratories/helpers\";\nimport type { Branded } from \"../branding\";\nimport { ServiceAlreadyRegisteredError, ServiceInvalidIdError } from \"../errors\";\nimport type { Services } from \"./service_declarations\";\n\nexport type ServiceTypesLike<\n  Model = unknown,\n  Ui = unknown,\n  Kind extends ServiceType = ServiceType,\n> = {\n  readonly __types?: { model: Model; ui: Ui; kind: Kind };\n};\n\nexport type InferServiceModel<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<infer M, unknown, ServiceType> ? M : unknown;\n\nexport type InferServiceUi<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, infer U, ServiceType> ? U : unknown;\n\nexport type InferServiceKind<S extends ServiceTypesLike> =\n  S extends ServiceTypesLike<unknown, unknown, infer K> ? K : ServiceType;\n\nexport type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded<string, S>;\n\nexport type ServiceType = \"node\" | \"wasm\";\n\nconst SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;\n\nexport const { service, isNodeService } = (() => {\n  const typeMap = new Map<string, ServiceType>();\n  return {\n    service<Model, Ui>() {\n      return <K extends ServiceType, N extends string>(options: {\n        readonly type: K;\n        readonly name: N;\n      }): Branded<N, ServiceTypesLike<Model, Ui, K>> => {\n        const { name, type } = options;\n        if (!SERVICE_ID_PATTERN.test(name)) {\n          throw new ServiceInvalidIdError(\n            `Invalid service ID \"${name}\": must match ${SERVICE_ID_PATTERN}`,\n          );\n        }\n        if (typeMap.has(name)) {\n          throw new ServiceAlreadyRegisteredError(`Service \"${name}\" already registered`);\n        }\n        typeMap.set(name, type);\n        return name as Branded<N, ServiceTypesLike<Model, Ui, K>>;\n      };\n    },\n    isNodeService(id: ServiceName): boolean {\n      return typeMap.get(id) === \"node\";\n    },\n  };\n})();\n\nexport function serviceFnKey(serviceId: string, method = \"\"): string {\n  return `service:${serviceId}:${method}`;\n}\n\nexport type ServiceBrand<T> =\n  T extends Branded<string, infer S extends ServiceTypesLike> ? S : never;\n\nexport type ModelServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceModel<ServiceBrand<SMap[K]>>) | null;\n};\n\nexport type UiServiceFactoryMap<SMap extends Record<string, ServiceName>> = {\n  [K in keyof SMap]: (() => InferServiceUi<ServiceBrand<SMap[K]>>) | null;\n};\n\n/** Contract between any service provider and any service consumer. */\nexport interface ServiceDispatch {\n  getServiceNames(): ServiceName[];\n  getServiceMethods(serviceId: ServiceName): string[];\n  callServiceMethod(serviceId: ServiceName, method: string, ...args: unknown[]): unknown;\n}\n\n// Auto-derived types from the Services const in service_declarations.ts.\n// Adding a service to Services automatically updates all of these.\n\ntype TServices = typeof Services;\n\ntype ExtractServiceName<T> = T extends Branded<infer N extends string, any> ? N : never;\n\n/** Model-side service interfaces keyed by service name literal. */\nexport type ModelServices = {\n  [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceModel<\n    ServiceBrand<TServices[K]>\n  >;\n};\n\n/** UI-side service interfaces keyed by service name literal. */\nexport type UiServices = {\n  [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<\n    ServiceBrand<TServices[K]>\n  >;\n};\n\n/** Map from Services keys to their unbranded string name literals. */\nexport type ServiceNameLiterals = {\n  [K in keyof TServices]: ExtractServiceName<TServices[K]>;\n};\n\n/** Auto-derived requires* feature flags from Services keys. */\nexport type ServiceRequireFlags = {\n  [K in keyof TServices as `requires${K & string}`]?: boolean;\n};\n\nexport type RequireServices<T extends ServiceName> = UnionToIntersection<\n  T extends Branded<infer N extends string, infer S extends ServiceTypesLike>\n    ? Record<N, InferServiceModel<S>>\n    : never\n>;\n"],"mappings":";;AA0BA,MAAM,qBAAqB;AAE3B,MAAa,EAAE,SAAS,yBAAyB;CAC/C,MAAM,0BAAU,IAAI,KAA0B;AAC9C,QAAO;EACL,UAAqB;AACnB,WAAiD,YAGC;IAChD,MAAM,EAAE,MAAM,SAAS;AACvB,QAAI,CAAC,mBAAmB,KAAK,KAAK,CAChC,OAAM,IAAI,sBACR,uBAAuB,KAAK,gBAAgB,qBAC7C;AAEH,QAAI,QAAQ,IAAI,KAAK,CACnB,OAAM,IAAI,8BAA8B,YAAY,KAAK,sBAAsB;AAEjF,YAAQ,IAAI,MAAM,KAAK;AACvB,WAAO;;;EAGX,cAAc,IAA0B;AACtC,UAAO,QAAQ,IAAI,GAAG,KAAK;;EAE9B;IACC;AAEJ,SAAgB,aAAa,WAAmB,SAAS,IAAY;AACnE,QAAO,WAAW,UAAU,GAAG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.34.0",
+  "version": "1.35.0",
   "description": "Platforma SDK Model",
   "files": [
     "./dist/**/*",
@@ -26,9 +26,9 @@
     "@vitest/coverage-istanbul": "^4.1.3",
     "typescript": "~5.9.3",
     "vitest": "^4.1.3",
-    "@milaboratories/ts-configs": "1.2.3",
     "@milaboratories/build-configs": "2.0.0",
-    "@milaboratories/ts-builder": "1.3.2"
+    "@milaboratories/ts-builder": "1.3.2",
+    "@milaboratories/ts-configs": "1.2.3"
   },
   "scripts": {
     "build": "ts-builder build --target node",

package/src/drivers/pframe/spec/anchored.ts

@@ -31,9 +31,9 @@ function domainKey(key: string, value: string): string {
  * Maintains maps of known domain values and axes that can be referenced by anchors
  */
 export class AnchoredIdDeriver {
+  private readonly axes = new Map<string, AnchorAxisRefByIdx>();
   private readonly domains = new Map<string, string>();
   private readonly contextDomains = new Map<string, string>();
-  private readonly axes = new Map<string, AnchorAxisRefByIdx>();
   /**
    * Domain packs are used to group domain keys that can be anchored to the same anchor
    * This is used to optimize the lookup of domain anchors
@@ -244,6 +244,7 @@ export type ResolveAnchorsOptions = {
  * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved
  * @param options - Options for resolving anchors
  * @returns A non-anchored column matcher with all references resolved to actual values
+ * @deprecated - This function by parent PColumnCollection
  */
 export function resolveAnchors(
   anchors: Record<string, Pick<PColumnSpec, "axesSpec" | "domain" | "contextDomain">>,

package/src/drivers/pframe/spec/discovered_column.ts

@@ -0,0 +1,65 @@
+import { Branded, throwError } from "@milaboratories/helpers";
+import { PObjectId } from "../../../pool";
+import { AxisQualification } from "../spec_driver";
+import { canonicalizeJson } from "../../../json";
+
+export type DiscoveredPColumn = {
+  path: PathItem[];
+  column: PObjectId;
+  columnQualifications: AxisQualification[];
+  queriesQualifications: Record<PObjectId, AxisQualification[]>;
+};
+
+export type DiscoveredPColumnId = Branded<PObjectId, "DiscoveredPColumnId">; // CanonicalizedJson<DiscoveredPColumn>;
+
+type PathItem = {
+  type: "linker";
+  column: PObjectId;
+  qualifications: AxisQualification[];
+};
+
+export function isDiscoveredPColumn(obj: unknown): obj is DiscoveredPColumn {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    "path" in obj &&
+    "column" in obj &&
+    "columnQualifications" in obj &&
+    "queriesQualifications" in obj
+  );
+}
+
+export function createDiscoveredPColumn(props: {
+  column: PObjectId;
+  path: PathItem[];
+  columnQualifications: AxisQualification[];
+  queriesQualifications: Record<PObjectId, AxisQualification[]>;
+}): DiscoveredPColumn {
+  return JSON.parse(JSON.stringify(props));
+}
+
+export function createDiscoveredPColumnId(props: {
+  column: PObjectId;
+  path: PathItem[];
+  columnQualifications: AxisQualification[];
+  queriesQualifications: Record<PObjectId, AxisQualification[]>;
+}): DiscoveredPColumnId {
+  return stringifyDiscoveredPColumnId(createDiscoveredPColumn(props));
+}
+
+export function parseDiscoveredPColumnId(id: DiscoveredPColumnId): DiscoveredPColumn {
+  try {
+    const parsed = JSON.parse(id);
+    return isDiscoveredPColumn(parsed)
+      ? parsed
+      : throwError("Parsed object is not a valid DiscoveredPColumn");
+  } catch {
+    throw new Error(
+      "Invalid DiscoveredPColumnId: not a valid JSON or does not conform to DiscoveredPColumn structure",
+    );
+  }
+}
+
+export function stringifyDiscoveredPColumnId(id: DiscoveredPColumn) {
+  return canonicalizeJson<DiscoveredPColumn>(id) as string as DiscoveredPColumnId;
+}

package/src/drivers/pframe/spec/ids.ts

@@ -3,10 +3,12 @@ import type { AnchoredPColumnId } from "./selectors";
 import type { FilteredPColumnId } from "./filtered_column";
 import canonicalize from "canonicalize";
 import type { PObjectId } from "../../../pool";
+import { DiscoveredPColumn } from "./discovered_column";
+
 /**
  * Universal column identifier optionally anchored and optionally filtered.
  */
-export type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId;
+export type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId | DiscoveredPColumn;
 
 /**
  * Canonically serialized {@link UniversalPColumnId}.

package/src/drivers/pframe/spec/index.ts

@@ -4,3 +4,4 @@ export * from "./filtered_column";
 export * from "./spec";
 export * from "./selectors";
 export * from "./native_id";
+export * from "./discovered_column";

package/src/drivers/pframe/spec/spec.ts

@@ -164,6 +164,7 @@ export const Annotation = {
     FontFamily: "pl7.app/table/fontFamily",
     OrderPriority: "pl7.app/table/orderPriority",
     Visibility: "pl7.app/table/visibility",
+    Info: "pl7.app/table/info",
   },
   Trace: "pl7.app/trace",
   VDJ: {
@@ -205,6 +206,7 @@ export type Annotation = Metadata &
     [Annotation.Table.FontFamily]: string;
     [Annotation.Table.OrderPriority]: StringifiedJson<number>;
     [Annotation.Table.Visibility]: "hidden" | "optional" | (string & {});
+    [Annotation.Table.Info]: string;
     [Annotation.Trace]: StringifiedJson<Trace>;
     [Annotation.VDJ.IsAssemblingFeature]: StringifiedJson<boolean>;
   }>;

package/src/ref.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { createPlRef, isPlRef, isPrimaryRef } from "./ref";
+
+const sampleRef = createPlRef("block1", "output1", true);
+
+describe("isPrimaryRef", () => {
+  it("returns true for a valid PrimaryRef", () => {
+    expect(isPrimaryRef({ __isPrimaryRef: "v1", column: sampleRef })).toBe(true);
+  });
+
+  it("returns true for PrimaryRef with filter", () => {
+    const filter = createPlRef("block1", "filter1");
+    expect(isPrimaryRef({ __isPrimaryRef: "v1", column: sampleRef, filter })).toBe(true);
+  });
+
+  it("returns false for a PlRef", () => {
+    expect(isPrimaryRef(sampleRef)).toBe(false);
+  });
+
+  it("returns false for null", () => {
+    expect(isPrimaryRef(null)).toBe(false);
+  });
+
+  it("returns false for a plain object", () => {
+    expect(isPrimaryRef({ foo: "bar" })).toBe(false);
+  });
+});
+
+describe("isPlRef", () => {
+  it("returns false for a PrimaryRef", () => {
+    expect(isPlRef({ __isPrimaryRef: "v1", column: sampleRef })).toBe(false);
+  });
+
+  it("returns true for a PlRef", () => {
+    expect(isPlRef(sampleRef)).toBe(true);
+  });
+});